← Back to branch summary

~ubuntu-branches/ubuntu/vivid/ffmpeg/vivid

« back to all changes in this revision

Viewing changes to libavcodec/flac.c

  • Committer: Package Import Robot
  • Author(s): Andreas Cadhalpun
  • Date: 2014-11-05 01:18:23 UTC
  • mfrom: (0.2.17 sid)
  • Revision ID: package-import@ubuntu.com-20141105011823-xsbeceffs43wtkn7
Tags: 7:2.4.3-1
* Import new upstream bugfix release 2.4.3.
   - Refresh Change-symbol-versioning.patch.
   - Add new symbols to the libavdevice symbols file.
* Enable libbs2b on arm64, since it is now available.
* Disable frei0r and libx264 on x32, libsoxr and openal on sparc64
  and libopencv on m68k, sh4, sparc64 and x32, because they are not
  (yet) avialable there.
* Disable assembler optimizations on x32, as they wouldn't work there.
* Include config.log in the build-log, when compiling fails.
* Add fix-hppa-tests.patch to work around a gcc bug on hppa.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/flac.c
19
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
20
 */
21
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"
22
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
static int64_t get_utf8(GetBitContext *gb)
 
44
{
 
45
    int64_t val;
 
46
    GET_UTF8(val, get_bits(gb, 8), return -1;)
 
47
    return val;
 
48
}
 
49
 
 
50
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
    if ((get_bits(gb, 15) & 0x7FFF) != 0x7FFC) {
 
57
        av_log(avctx, AV_LOG_ERROR + log_level_offset, "invalid sync code\n");
 
58
        return AVERROR_INVALIDDATA;
 
59
    }
 
60
 
 
61
    /* variable block size stream code */
 
62
    fi->is_var_size = get_bits1(gb);
 
63
 
 
64
    /* block size and sample rate codes */
 
65
    bs_code = get_bits(gb, 4);
 
66
    sr_code = get_bits(gb, 4);
 
67
 
 
68
    /* channels and decorrelation */
 
69
    fi->ch_mode = get_bits(gb, 4);
 
70
    if (fi->ch_mode < FLAC_MAX_CHANNELS) {
 
71
        fi->channels = fi->ch_mode + 1;
 
72
        fi->ch_mode = FLAC_CHMODE_INDEPENDENT;
 
73
    } else if (fi->ch_mode < FLAC_MAX_CHANNELS + FLAC_CHMODE_MID_SIDE) {
 
74
        fi->channels = 2;
 
75
        fi->ch_mode -= FLAC_MAX_CHANNELS - 1;
 
76
    } else {
 
77
        av_log(avctx, AV_LOG_ERROR + log_level_offset,
 
78
               "invalid channel mode: %d\n", fi->ch_mode);
 
79
        return AVERROR_INVALIDDATA;
 
80
    }
 
81
 
 
82
    /* bits per sample */
 
83
    bps_code = get_bits(gb, 3);
 
84
    if (bps_code == 3 || bps_code == 7) {
 
85
        av_log(avctx, AV_LOG_ERROR + log_level_offset,
 
86
               "invalid sample size code (%d)\n",
 
87
               bps_code);
 
88
        return AVERROR_INVALIDDATA;
 
89
    }
 
90
    fi->bps = sample_size_table[bps_code];
 
91
 
 
92
    /* reserved bit */
 
93
    if (get_bits1(gb)) {
 
94
        av_log(avctx, AV_LOG_ERROR + log_level_offset,
 
95
               "broken stream, invalid padding\n");
 
96
        return AVERROR_INVALIDDATA;
 
97
    }
 
98
 
 
99
    /* sample or frame count */
 
100
    fi->frame_or_sample_num = get_utf8(gb);
 
101
    if (fi->frame_or_sample_num < 0) {
 
102
        av_log(avctx, AV_LOG_ERROR + log_level_offset,
 
103
               "sample/frame number invalid; utf8 fscked\n");
 
104
        return AVERROR_INVALIDDATA;
 
105
    }
 
106
 
 
107
    /* blocksize */
 
108
    if (bs_code == 0) {
 
109
        av_log(avctx, AV_LOG_ERROR + log_level_offset,
 
110
               "reserved blocksize code: 0\n");
 
111
        return AVERROR_INVALIDDATA;
 
112
    } else if (bs_code == 6) {
 
113
        fi->blocksize = get_bits(gb, 8) + 1;
 
114
    } else if (bs_code == 7) {
 
115
        fi->blocksize = get_bits(gb, 16) + 1;
 
116
    } else {
 
117
        fi->blocksize = ff_flac_blocksize_table[bs_code];
 
118
    }
 
119
 
 
120
    /* sample rate */
 
121
    if (sr_code < 12) {
 
122
        fi->samplerate = ff_flac_sample_rate_table[sr_code];
 
123
    } else if (sr_code == 12) {
 
124
        fi->samplerate = get_bits(gb, 8) * 1000;
 
125
    } else if (sr_code == 13) {
 
126
        fi->samplerate = get_bits(gb, 16);
 
127
    } else if (sr_code == 14) {
 
128
        fi->samplerate = get_bits(gb, 16) * 10;
 
129
    } else {
 
130
        av_log(avctx, AV_LOG_ERROR + log_level_offset,
 
131
               "illegal sample rate code %d\n",
 
132
               sr_code);
 
133
        return AVERROR_INVALIDDATA;
 
134
    }
 
135
 
 
136
    /* header CRC-8 check */
 
137
    skip_bits(gb, 8);
 
138
    if (av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, gb->buffer,
 
139
               get_bits_count(gb)/8)) {
 
140
        av_log(avctx, AV_LOG_ERROR + log_level_offset,
 
141
               "header crc mismatch\n");
 
142
        return AVERROR_INVALIDDATA;
 
143
    }
 
144
 
 
145
    return 0;
 
146
}
23
147
 
24
148
int ff_flac_get_max_frame_size(int blocksize, int ch, int bps)
25
149
{
41
165
 
42
166
    return count;
43
167
}
 
168
 
 
169
int avpriv_flac_is_extradata_valid(AVCodecContext *avctx,
 
170
                               enum FLACExtradataFormat *format,
 
171
                               uint8_t **streaminfo_start)
 
172
{
 
173
    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
    if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
 
178
        /* extradata contains STREAMINFO only */
 
179
        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
        *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
 
184
        *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
    return 1;
 
194
}
 
195
 
 
196
void ff_flac_set_channel_layout(AVCodecContext *avctx)
 
197
{
 
198
    if (avctx->channels <= FF_ARRAY_ELEMS(flac_channel_layouts))
 
199
        avctx->channel_layout = flac_channel_layouts[avctx->channels - 1];
 
200
    else
 
201
        avctx->channel_layout = 0;
 
202
}
 
203
 
 
204
void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
 
205
                              const uint8_t *buffer)
 
206
{
 
207
    GetBitContext gb;
 
208
    init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
 
209
 
 
210
    skip_bits(&gb, 16); /* skip min blocksize */
 
211
    s->max_blocksize = get_bits(&gb, 16);
 
212
    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
    }
 
217
 
 
218
    skip_bits(&gb, 24); /* skip min frame size */
 
219
    s->max_framesize = get_bits_long(&gb, 24);
 
220
 
 
221
    s->samplerate = get_bits_long(&gb, 20);
 
222
    s->channels = get_bits(&gb, 3) + 1;
 
223
    s->bps = get_bits(&gb, 5) + 1;
 
224
 
 
225
    avctx->channels = s->channels;
 
226
    avctx->sample_rate = s->samplerate;
 
227
    avctx->bits_per_raw_sample = s->bps;
 
228
 
 
229
    if (!avctx->channel_layout ||
 
230
        av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels)
 
231
        ff_flac_set_channel_layout(avctx);
 
232
 
 
233
    s->samples = get_bits64(&gb, 36);
 
234
 
 
235
    skip_bits_long(&gb, 64); /* md5 sum */
 
236
    skip_bits_long(&gb, 64); /* md5 sum */
 
237
}