GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/flac.c Lines: 95 111 85.6 %
Date: 2019-11-20 04:07:19 Branches: 49 60 81.7 %

Line Branch Exec Source
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


11649
    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
        av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
175
        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
            av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
181
                   FLAC_STREAMINFO_SIZE-avctx->extradata_size);
182
        }
183
53
        *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
184
53
        *streaminfo_start = avctx->extradata;
185
    } else {
186
        if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
187
            av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
188
            return 0;
189
        }
190
        *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
191
        *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
        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
        av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
214
               s->max_blocksize);
215
        s->max_blocksize = 16;
216
        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
        av_log(avctx, AV_LOG_ERROR, "invalid bps: %d\n", s->bps);
228
        s->bps = 16;
229
        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
53
    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
}