LCOV - code coverage report
Current view: top level - libavcodec - flac.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 95 111 85.6 %
Date: 2017-12-14 08:27:08 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /*
       2             :  * FLAC common code
       3             :  * Copyright (c) 2009 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/channel_layout.h"
      23             : #include "libavutil/crc.h"
      24             : #include "libavutil/log.h"
      25             : #include "bytestream.h"
      26             : #include "get_bits.h"
      27             : #include "flac.h"
      28             : #include "flacdata.h"
      29             : 
      30             : static const int8_t sample_size_table[] = { 0, 8, 12, 0, 16, 20, 24, 0 };
      31             : 
      32             : static const uint64_t flac_channel_layouts[8] = {
      33             :     AV_CH_LAYOUT_MONO,
      34             :     AV_CH_LAYOUT_STEREO,
      35             :     AV_CH_LAYOUT_SURROUND,
      36             :     AV_CH_LAYOUT_QUAD,
      37             :     AV_CH_LAYOUT_5POINT0,
      38             :     AV_CH_LAYOUT_5POINT1,
      39             :     AV_CH_LAYOUT_6POINT1,
      40             :     AV_CH_LAYOUT_7POINT1
      41             : };
      42             : 
      43        9744 : static int64_t get_utf8(GetBitContext *gb)
      44             : {
      45             :     int64_t val;
      46        9744 :     GET_UTF8(val, get_bits(gb, 8), return -1;)
      47        9671 :     return val;
      48             : }
      49             : 
      50       10300 : int ff_flac_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb,
      51             :                                 FLACFrameInfo *fi, int log_level_offset)
      52             : {
      53             :     int bs_code, sr_code, bps_code;
      54             : 
      55             :     /* frame sync code */
      56       10300 :     if ((get_bits(gb, 15) & 0x7FFF) != 0x7FFC) {
      57           1 :         av_log(avctx, AV_LOG_ERROR + log_level_offset, "invalid sync code\n");
      58           1 :         return AVERROR_INVALIDDATA;
      59             :     }
      60             : 
      61             :     /* variable block size stream code */
      62       10299 :     fi->is_var_size = get_bits1(gb);
      63             : 
      64             :     /* block size and sample rate codes */
      65       10299 :     bs_code = get_bits(gb, 4);
      66       10299 :     sr_code = get_bits(gb, 4);
      67             : 
      68             :     /* channels and decorrelation */
      69       10299 :     fi->ch_mode = get_bits(gb, 4);
      70       10299 :     if (fi->ch_mode < FLAC_MAX_CHANNELS) {
      71        3686 :         fi->channels = fi->ch_mode + 1;
      72        3686 :         fi->ch_mode = FLAC_CHMODE_INDEPENDENT;
      73        6613 :     } else if (fi->ch_mode < FLAC_MAX_CHANNELS + FLAC_CHMODE_MID_SIDE) {
      74        6383 :         fi->channels = 2;
      75        6383 :         fi->ch_mode -= FLAC_MAX_CHANNELS - 1;
      76             :     } else {
      77         230 :         av_log(avctx, AV_LOG_ERROR + log_level_offset,
      78             :                "invalid channel mode: %d\n", fi->ch_mode);
      79         230 :         return AVERROR_INVALIDDATA;
      80             :     }
      81             : 
      82             :     /* bits per sample */
      83       10069 :     bps_code = get_bits(gb, 3);
      84       10069 :     if (bps_code == 3 || bps_code == 7) {
      85         127 :         av_log(avctx, AV_LOG_ERROR + log_level_offset,
      86             :                "invalid sample size code (%d)\n",
      87             :                bps_code);
      88         127 :         return AVERROR_INVALIDDATA;
      89             :     }
      90        9942 :     fi->bps = sample_size_table[bps_code];
      91             : 
      92             :     /* reserved bit */
      93        9942 :     if (get_bits1(gb)) {
      94         198 :         av_log(avctx, AV_LOG_ERROR + log_level_offset,
      95             :                "broken stream, invalid padding\n");
      96         198 :         return AVERROR_INVALIDDATA;
      97             :     }
      98             : 
      99             :     /* sample or frame count */
     100        9744 :     fi->frame_or_sample_num = get_utf8(gb);
     101        9744 :     if (fi->frame_or_sample_num < 0) {
     102          73 :         av_log(avctx, AV_LOG_ERROR + log_level_offset,
     103             :                "sample/frame number invalid; utf8 fscked\n");
     104          73 :         return AVERROR_INVALIDDATA;
     105             :     }
     106             : 
     107             :     /* blocksize */
     108        9671 :     if (bs_code == 0) {
     109          22 :         av_log(avctx, AV_LOG_ERROR + log_level_offset,
     110             :                "reserved blocksize code: 0\n");
     111          22 :         return AVERROR_INVALIDDATA;
     112        9649 :     } else if (bs_code == 6) {
     113           4 :         fi->blocksize = get_bits(gb, 8) + 1;
     114        9645 :     } else if (bs_code == 7) {
     115          84 :         fi->blocksize = get_bits(gb, 16) + 1;
     116             :     } else {
     117        9561 :         fi->blocksize = ff_flac_blocksize_table[bs_code];
     118             :     }
     119             : 
     120             :     /* sample rate */
     121        9649 :     if (sr_code < 12) {
     122        8577 :         fi->samplerate = ff_flac_sample_rate_table[sr_code];
     123        1072 :     } else if (sr_code == 12) {
     124        1049 :         fi->samplerate = get_bits(gb, 8) * 1000;
     125          23 :     } else if (sr_code == 13) {
     126           7 :         fi->samplerate = get_bits(gb, 16);
     127          16 :     } else if (sr_code == 14) {
     128           6 :         fi->samplerate = get_bits(gb, 16) * 10;
     129             :     } else {
     130          10 :         av_log(avctx, AV_LOG_ERROR + log_level_offset,
     131             :                "illegal sample rate code %d\n",
     132             :                sr_code);
     133          10 :         return AVERROR_INVALIDDATA;
     134             :     }
     135             : 
     136             :     /* header CRC-8 check */
     137        9639 :     skip_bits(gb, 8);
     138        9639 :     if (av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, gb->buffer,
     139        9639 :                get_bits_count(gb)/8)) {
     140          91 :         av_log(avctx, AV_LOG_ERROR + log_level_offset,
     141             :                "header crc mismatch\n");
     142          91 :         return AVERROR_INVALIDDATA;
     143             :     }
     144             : 
     145        9548 :     return 0;
     146             : }
     147             : 
     148          56 : int ff_flac_get_max_frame_size(int blocksize, int ch, int bps)
     149             : {
     150             :     /* Technically, there is no limit to FLAC frame size, but an encoder
     151             :        should not write a frame that is larger than if verbatim encoding mode
     152             :        were to be used. */
     153             : 
     154             :     int count;
     155             : 
     156          56 :     count = 16;                  /* frame header */
     157          56 :     count += ch * ((7+bps+7)/8); /* subframe headers */
     158          56 :     if (ch == 2) {
     159             :         /* for stereo, need to account for using decorrelation */
     160          30 :         count += (( 2*bps+1) * blocksize + 7) / 8;
     161             :     } else {
     162          26 :         count += ( ch*bps    * blocksize + 7) / 8;
     163             :     }
     164          56 :     count += 2; /* frame footer */
     165             : 
     166          56 :     return count;
     167             : }
     168             : 
     169          53 : int ff_flac_is_extradata_valid(AVCodecContext *avctx,
     170             :                                enum FLACExtradataFormat *format,
     171             :                                uint8_t **streaminfo_start)
     172             : {
     173          53 :     if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
     174           0 :         av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
     175           0 :         return 0;
     176             :     }
     177          53 :     if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
     178             :         /* extradata contains STREAMINFO only */
     179          53 :         if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
     180           0 :             av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
     181           0 :                    FLAC_STREAMINFO_SIZE-avctx->extradata_size);
     182             :         }
     183          53 :         *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
     184          53 :         *streaminfo_start = avctx->extradata;
     185             :     } else {
     186           0 :         if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
     187           0 :             av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
     188           0 :             return 0;
     189             :         }
     190           0 :         *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
     191           0 :         *streaminfo_start = &avctx->extradata[8];
     192             :     }
     193          53 :     return 1;
     194             : }
     195             : 
     196          28 : void ff_flac_set_channel_layout(AVCodecContext *avctx)
     197             : {
     198          28 :     if (avctx->channels <= FF_ARRAY_ELEMS(flac_channel_layouts))
     199          28 :         avctx->channel_layout = flac_channel_layouts[avctx->channels - 1];
     200             :     else
     201           0 :         avctx->channel_layout = 0;
     202          28 : }
     203             : 
     204          53 : int ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
     205             :                               const uint8_t *buffer)
     206             : {
     207             :     GetBitContext gb;
     208          53 :     init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
     209             : 
     210          53 :     skip_bits(&gb, 16); /* skip min blocksize */
     211          53 :     s->max_blocksize = get_bits(&gb, 16);
     212          53 :     if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
     213           0 :         av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
     214             :                s->max_blocksize);
     215           0 :         s->max_blocksize = 16;
     216           0 :         return AVERROR_INVALIDDATA;
     217             :     }
     218             : 
     219          53 :     skip_bits(&gb, 24); /* skip min frame size */
     220          53 :     s->max_framesize = get_bits_long(&gb, 24);
     221             : 
     222          53 :     s->samplerate = get_bits_long(&gb, 20);
     223          53 :     s->channels = get_bits(&gb, 3) + 1;
     224          53 :     s->bps = get_bits(&gb, 5) + 1;
     225             : 
     226          53 :     if (s->bps < 4) {
     227           0 :         av_log(avctx, AV_LOG_ERROR, "invalid bps: %d\n", s->bps);
     228           0 :         s->bps = 16;
     229           0 :         return AVERROR_INVALIDDATA;
     230             :     }
     231             : 
     232          53 :     avctx->channels = s->channels;
     233          53 :     avctx->sample_rate = s->samplerate;
     234          53 :     avctx->bits_per_raw_sample = s->bps;
     235             : 
     236          78 :     if (!avctx->channel_layout ||
     237          25 :         av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels)
     238          28 :         ff_flac_set_channel_layout(avctx);
     239             : 
     240          53 :     s->samples = get_bits64(&gb, 36);
     241             : 
     242          53 :     skip_bits_long(&gb, 64); /* md5 sum */
     243          53 :     skip_bits_long(&gb, 64); /* md5 sum */
     244             : 
     245          53 :     return 0;
     246             : }

Generated by: LCOV version 1.13