43 #define FLAC_MAX_SEQUENTIAL_HEADERS 4
45 #define FLAC_MIN_HEADERS 10
47 #define FLAC_AVG_FRAME_SIZE 8192
50 #define FLAC_HEADER_BASE_SCORE 10
51 #define FLAC_HEADER_CHANGED_PENALTY 7
52 #define FLAC_HEADER_CRC_FAIL_PENALTY 50
53 #define FLAC_HEADER_NOT_PENALIZED_YET 100000
54 #define FLAC_HEADER_NOT_SCORED_YET -100000
57 #define MAX_FRAME_HEADER_SIZE 16
58 #define MAX_FRAME_VERIFY_SIZE (MAX_FRAME_HEADER_SIZE)
118 uint8_t **wrap_buf,
int *allocated_size)
125 start -=
f->end -
f->buffer;
126 if (
f->end - start >=
len)
133 "couldn't reallocate wrap buffer of size %d",
len);
138 int seg_len =
FFMIN(
f->end - start,
len);
139 memcpy(tmp_buf, start, seg_len);
140 tmp_buf = (
uint8_t*)tmp_buf + seg_len;
143 start += seg_len - (
f->end -
f->buffer);
163 start -=
f->end -
f->buffer;
182 while (*end_handle) {
183 end_handle = &(*end_handle)->
next;
187 *end_handle =
av_mallocz(
sizeof(**end_handle));
190 "couldn't allocate FLACHeaderMarker\n");
193 (*end_handle)->fi = fi;
194 (*end_handle)->offset =
offset;
206 int buf_size,
int search_start)
208 int size = 0, mod_offset = (buf_size - 1) % 4,
i, j;
211 for (
i = 0;
i < mod_offset;
i++) {
212 if ((
AV_RB16(buf +
i) & 0xFFFE) == 0xFFF8) {
218 for (;
i < buf_size - 1;
i += 4) {
220 if (((x & ~(x + 0x01010101)) & 0x80808080)) {
221 for (j = 0; j < 4; j++) {
222 if ((
AV_RB16(buf +
i + j) & 0xFFFE) == 0xFFF8) {
235 int search_end,
size = 0, read_len,
temp;
241 read_len = search_end - search_start + 1;
244 search_start += read_len - 1;
247 if (search_start != search_end) {
250 wrap[0] = buf[read_len - 1];
252 read_len = search_end - (search_start + 1) + 1;
266 search_start += read_len - 1;
279 int log_level_offset)
282 if (child_fi->samplerate != header_fi->samplerate) {
285 "sample rate change detected in adjacent frames\n");
287 if (child_fi->bps != header_fi->bps) {
290 "bits per sample change detected in adjacent frames\n");
296 "blocking strategy change detected in adjacent frames\n");
298 if (child_fi->channels != header_fi->channels) {
301 "number of channels change detected in adjacent frames\n");
309 int log_level_offset)
312 int deduction, deduction_expected = 0,
i;
318 (child_fi->frame_or_sample_num
321 int64_t expected_frame_num, expected_sample_num;
327 while (curr != child) {
331 expected_frame_num++;
339 if (expected_frame_num == child_fi->frame_or_sample_num ||
340 expected_sample_num == child_fi->frame_or_sample_num)
341 deduction_expected = deduction ? 0 : 1;
345 "sample/frame number mismatch in adjacent frames\n");
349 if (deduction && !deduction_expected) {
354 int inverted_test = 0;
372 while (start->
next != child)
376 header->next->link_penalty[
i-1] >=
393 if (!crc ^ !inverted_test) {
396 "crc check failed from offset %i (frame %"PRId64
") to %i (frame %"PRId64
")\n",
398 child->
offset, child_fi->frame_or_sample_num);
430 header->max_score = base_score;
445 header->best_child = child;
446 header->max_score = base_score + child_score;
463 for (curr = fpc->
headers; curr; curr = curr->
next) {
498 if (
header->fi.is_var_size)
500 else if (
header->best_child)
516 const uint8_t **poutbuf,
int *poutbuf_size,
517 const uint8_t *buf,
int buf_size)
523 const uint8_t *read_start = buf;
538 *poutbuf_size = buf_size;
552 for (curr = fpc->
headers; curr != best_child; curr =
temp) {
555 "dropping low score %i frame header from offset %i to %i\n",
566 for (curr = best_child->
next; curr; curr = curr->
next)
594 while ((buf_size && read_end < buf + buf_size &&
607 read_end = read_end +
FFMIN(buf + buf_size - read_end,
631 read_end - read_start,
NULL);
640 start_offset =
FFMAX(0, start_offset);
643 if (nb_headers < 0) {
645 "find_new_headers couldn't allocate FLAC header\n");
652 if (read_end < buf + buf_size) {
653 read_start = read_end;
674 read_start = read_end =
NULL;
678 for (curr = fpc->
headers; curr; curr = curr->
next) {
713 return buf_size ? read_end - buf : 0;
725 "couldn't allocate fifo_buf\n");
Macro definitions for various function/variable attributes.
#define PARSER_FLAG_USE_CODEC_TS
#define PARSER_FLAG_COMPLETE_FRAMES
Public header for CRC hash function implementation.
a very simple circular buffer FIFO implementation
int ff_flac_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, FLACFrameInfo *fi, int log_level_offset)
Validate and decode a frame header.
void ff_flac_set_channel_layout(AVCodecContext *avctx)
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
static uint8_t * flac_fifo_read(FLACParseContext *fpc, int offset, int *len)
Return a pointer in the fifo buffer where the offset starts at until the wrap point or end of request...
static void score_sequences(FLACParseContext *fpc)
#define FLAC_HEADER_CHANGED_PENALTY
#define FLAC_MAX_SEQUENTIAL_HEADERS
maximum number of adjacent headers that compare CRCs against each other
static void flac_parse_close(AVCodecParserContext *c)
static av_cold int flac_parse_init(AVCodecParserContext *c)
static int find_headers_search_validate(FLACParseContext *fpc, int offset)
static int score_header(FLACParseContext *fpc, FLACHeaderMarker *header)
Score a header.
#define FLAC_HEADER_NOT_SCORED_YET
static int check_header_mismatch(FLACParseContext *fpc, FLACHeaderMarker *header, FLACHeaderMarker *child, int log_level_offset)
static uint8_t * flac_fifo_read_wrap(FLACParseContext *fpc, int offset, int len, uint8_t **wrap_buf, int *allocated_size)
Non-destructive fast fifo pointer fetching Returns a pointer from the specified offset.
#define FLAC_HEADER_BASE_SCORE
scoring settings for score_header
#define FLAC_AVG_FRAME_SIZE
estimate for average size of a FLAC frame
#define MAX_FRAME_VERIFY_SIZE
#define FLAC_HEADER_NOT_PENALIZED_YET
static int frame_header_is_valid(AVCodecContext *avctx, const uint8_t *buf, FLACFrameInfo *fi)
static int check_header_fi_mismatch(FLACParseContext *fpc, FLACFrameInfo *header_fi, FLACFrameInfo *child_fi, int log_level_offset)
static int find_headers_search(FLACParseContext *fpc, uint8_t *buf, int buf_size, int search_start)
#define MAX_FRAME_HEADER_SIZE
largest possible size of flac header
AVCodecParser ff_flac_parser
#define FLAC_HEADER_CRC_FAIL_PENALTY
static int get_best_header(FLACParseContext *fpc, const uint8_t **poutbuf, int *poutbuf_size)
static int flac_parse(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size)
#define FLAC_MIN_HEADERS
minimum number of headers buffered and checked before returning frames
static int find_new_headers(FLACParseContext *fpc, int search_start)
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
void av_fifo_drain(AVFifoBuffer *f, int size)
Discard data from the FIFO.
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
int av_fifo_space(const AVFifoBuffer *f)
Return the amount of space in bytes in the AVFifoBuffer, that is the amount of data you can write int...
AVFifoBuffer * av_fifo_alloc_array(size_t nmemb, size_t size)
Initialize an AVFifoBuffer.
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int(*func)(void *, void *, int))
Feed data from a user-supplied callback to an AVFifoBuffer.
int av_fifo_realloc2(AVFifoBuffer *f, unsigned int new_size)
Resize an AVFifoBuffer.
#define PTRDIFF_SPECIFIER
static const uint8_t header[24]
main external API structure.
int sample_rate
samples per second
int channels
number of audio channels
uint64_t channel_layout
Audio channel layout.
int duration
Duration of the current frame.
int is_var_size
specifies if the stream uses variable block sizes or a fixed block size; also determines the meaning ...
int64_t frame_or_sample_num
frame number or sample number
FLACCOMMONINFO int blocksize
block size of the frame
uint8_t * wrap_buf
general fifo read buffer when wrapped
FLACHeaderMarker * headers
linked-list that starts at the first CRC-8 verified header within buffer
int last_fi_valid
set if last_fi is valid
FLACFrameInfo last_fi
last decoded frame header info
AVCodecContext * avctx
codec context pointer for logging
FLACHeaderMarker * best_header
highest scoring header within buffer
int nb_headers_buffered
number of headers that are buffered
AVFifoBuffer * fifo_buf
buffer to store all data until headers can be verified
int end_padded
specifies if fifo_buf's end is padded
int best_header_valid
flag set when the parser returns junk; if set return best_header next time
AVCodecParserContext * pc
parent context
int nb_headers_found
number of headers found in the last flac_parse() call
int wrap_buf_allocated_size
actual allocated size of the buffer
static const uint8_t offset[127][2]