35 #include "libavutil/attributes.h"
36 #include "libavutil/crc.h"
37 #include "libavutil/fifo.h"
43 #define FLAC_MAX_SEQUENTIAL_HEADERS 3
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
114 uint8_t** wrap_buf,
int* allocated_size)
122 if (f->
end - start >= len)
129 "couldn't reallocate wrap buffer of size %d", len);
134 int seg_len =
FFMIN(f->
end - start, len);
135 memcpy(tmp_buf, start, seg_len);
136 tmp_buf = (
uint8_t*)tmp_buf + seg_len;
178 while (*end_handle) {
179 end_handle = &(*end_handle)->
next;
186 "couldn't allocate FLACHeaderMarker\n");
189 (*end_handle)->fi = fi;
190 (*end_handle)->offset = offset;
191 (*end_handle)->link_penalty =
av_malloc(
sizeof(
int) *
206 int size = 0, mod_offset = (buf_size - 1) % 4, i, j;
209 for (i = 0; i < mod_offset; i++) {
210 if ((
AV_RB16(buf + i) & 0xFFFE) == 0xFFF8)
214 for (; i < buf_size - 1; i += 4) {
216 if (((x & ~(x + 0x01010101)) & 0x80808080)) {
217 for (j = 0; j < 4; j++) {
218 if ((
AV_RB16(buf + i + j) & 0xFFFE) == 0xFFF8)
229 int search_end,
size = 0, read_len, temp;
235 read_len = search_end - search_start + 1;
238 search_start += read_len - 1;
241 if (search_start != search_end) {
244 wrap[0] = buf[read_len - 1];
245 read_len = search_end - search_start + 1;
251 if ((
AV_RB16(wrap) & 0xFFFE) == 0xFFF8) {
253 size =
FFMAX(size, temp);
259 size =
FFMAX(size, temp);
260 search_start += read_len - 1;
273 int log_level_offset)
276 int deduction = 0, deduction_expected = 0, i;
277 if (child_fi->samplerate != header_fi->samplerate) {
280 "sample rate change detected in adjacent frames\n");
282 if (child_fi->bps != header_fi->bps) {
285 "bits per sample change detected in adjacent frames\n");
287 if (child_fi->is_var_size != header_fi->
is_var_size) {
291 "blocking strategy change detected in adjacent frames\n");
293 if (child_fi->channels != header_fi->channels) {
296 "number of channels change detected in adjacent frames\n");
301 (child_fi->frame_or_sample_num
304 int expected_frame_num, expected_sample_num;
310 while (curr != child) {
314 expected_frame_num++;
322 if (expected_frame_num == child_fi->frame_or_sample_num ||
323 expected_sample_num == child_fi->frame_or_sample_num)
324 deduction_expected = deduction ? 0 : 1;
328 "sample/frame number mismatch in adjacent frames\n");
332 if (deduction && !deduction_expected) {
337 int inverted_test = 0;
355 while (start->
next != child)
376 if (!crc ^ !inverted_test) {
379 "crc check failed from offset %i (frame %"PRId64
") to %i (frame %"PRId64
")\n",
381 child->
offset, child_fi->frame_or_sample_num);
409 child = header->
next;
439 for (curr = fpc->
headers; curr; curr = curr->
next) {
481 const uint8_t **poutbuf,
int *poutbuf_size,
482 const uint8_t *buf,
int buf_size)
488 const uint8_t *read_start = buf;
495 *poutbuf_size = buf_size;
509 for (curr = fpc->
headers; curr != best_child; curr = temp) {
512 "dropping low score %i frame header from offset %i to %i\n",
524 for (curr = best_child->
next; curr; curr = curr->
next)
550 while ((buf && read_end < buf + buf_size &&
564 read_end = read_end +
FFMIN(buf + buf_size - read_end,
572 "couldn't reallocate buffer of size %td\n",
579 read_end - read_start,
NULL);
588 start_offset =
FFMAX(0, start_offset);
591 if (nb_headers < 0) {
593 "find_new_headers couldn't allocate FLAC header\n");
600 if (buf && read_end < buf + buf_size) {
601 read_start = read_end;
622 read_start = read_end =
NULL;
654 return read_end - buf;
static int frame_header_is_valid(AVCodecContext *avctx, const uint8_t *buf, FLACFrameInfo *fi)
static void score_sequences(FLACParseContext *fpc)
#define AV_LOG_WARNING
Something somehow does not look correct.
int64_t frame_or_sample_num
frame number or sample number
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
AVFifoBuffer * fifo_buf
buffer to store all data until headers can be verified
int duration
Duration of the current frame.
#define FLAC_HEADER_CRC_FAIL_PENALTY
FLACCOMMONINFO int blocksize
block size of the frame
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
AVCodecContext * avctx
codec context pointer for logging
int best_header_valid
flag set when the parser returns junk; if set return best_header next time
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
int av_fifo_size(AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
#define FLAC_AVG_FRAME_SIZE
estimate for average size of a FLAC frame
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
#define FLAC_HEADER_NOT_SCORED_YET
static int get_best_header(FLACParseContext *fpc, const uint8_t **poutbuf, int *poutbuf_size)
#define FLAC_HEADER_CHANGED_PENALTY
static void flac_parse_close(AVCodecParserContext *c)
#define FLAC_MAX_SEQUENTIAL_HEADERS
maximum number of adjacent headers that compare CRCs against each other
void av_fifo_free(AVFifoBuffer *f)
Free an AVFifoBuffer.
static int flac_parse(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size)
void av_fifo_drain(AVFifoBuffer *f, int size)
Read and discard the specified amount of data from an AVFifoBuffer.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define PARSER_FLAG_COMPLETE_FRAMES
int ff_flac_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, FLACFrameInfo *fi, int log_level_offset)
Validate and decode a frame header.
uint64_t channel_layout
Audio channel layout.
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 size)
Resize an AVFifoBuffer.
int end_padded
specifies if fifo_buf's end is padded
FLACHeaderMarker * headers
linked-list that starts at the first CRC-8 verified header within buffer
#define FLAC_MIN_HEADERS
minimum number of headers buffered and checked before returning frames
void * av_malloc(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
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.
if(ac->has_optimized_func)
static int find_headers_search_validate(FLACParseContext *fpc, int offset)
uint8_t * wrap_buf
general fifo read buffer when wrapped
int sample_rate
samples per second
#define FLAC_HEADER_NOT_PENALIZED_YET
main external API structure.
static int find_new_headers(FLACParseContext *fpc, int search_start)
void ff_flac_set_channel_layout(AVCodecContext *avctx)
static int score_header(FLACParseContext *fpc, FLACHeaderMarker *header)
Score a header.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
int nb_headers_buffered
number of headers that are buffered
#define MAX_FRAME_HEADER_SIZE
largest possible size of flac header
AVCodecParserContext * pc
parent context
FLACHeaderMarker * best_header
highest scoring header within buffer
AVCodecParser ff_flac_parser
static int find_headers_search(FLACParseContext *fpc, uint8_t *buf, int buf_size, int search_start)
int channels
number of audio channels
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given block if it is not large enough, otherwise do nothing.
static av_cold int flac_parse_init(AVCodecParserContext *c)
#define FLAC_HEADER_BASE_SCORE
scoring settings for score_header
int is_var_size
specifies if the stream uses variable block sizes or a fixed block size; also determines the meaning ...
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length) av_pure
Calculate the CRC of a block.
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...
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
static int check_header_mismatch(FLACParseContext *fpc, FLACHeaderMarker *header, FLACHeaderMarker *child, int log_level_offset)