3 * Copyright (c) 2010 Michael Chinen
5 * This file is part of FFmpeg.
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.
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.
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
26 * The FLAC parser buffers input until FLAC_MIN_HEADERS has been found.
27 * Each time it finds and verifies a CRC-8 header it sees which of the
28 * FLAC_MAX_SEQUENTIAL_HEADERS that came before it have a valid CRC-16 footer
29 * that ends at the newly found header.
30 * Headers are scored by FLAC_HEADER_BASE_SCORE plus the max of its crc-verified
31 * children, penalized by changes in sample rate, frame number, etc.
32 * The parser returns the frame with the highest score.
35 #include "libavutil/attributes.h"
36 #include "libavutil/crc.h"
37 #include "libavutil/fifo.h"
38 #include "bytestream.h"
42 /** maximum number of adjacent headers that compare CRCs against each other */
43 #define FLAC_MAX_SEQUENTIAL_HEADERS 3
44 /** minimum number of headers buffered and checked before returning frames */
45 #define FLAC_MIN_HEADERS 10
46 /** estimate for average size of a FLAC frame */
47 #define FLAC_AVG_FRAME_SIZE 8192
49 /** scoring settings for score_header */
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
56 /** largest possible size of flac header */
57 #define MAX_FRAME_HEADER_SIZE 16
59 typedef struct FLACHeaderMarker
{
60 int offset
; /**< byte offset from start of FLACParseContext->buffer */
61 int *link_penalty
; /**< pointer to array of local scores between this header
62 and the one at a distance equal array position */
63 int max_score
; /**< maximum score found after checking each child that
65 FLACFrameInfo fi
; /**< decoded frame header info */
66 struct FLACHeaderMarker
*next
; /**< next CRC-8 verified header that
67 immediately follows this one in
69 struct FLACHeaderMarker
*best_child
; /**< following frame header with
70 which this frame has the best
74 typedef struct FLACParseContext
{
75 AVCodecParserContext
*pc
; /**< parent context */
76 AVCodecContext
*avctx
; /**< codec context pointer for logging */
77 FLACHeaderMarker
*headers
; /**< linked-list that starts at the first
78 CRC-8 verified header within buffer */
79 FLACHeaderMarker
*best_header
; /**< highest scoring header within buffer */
80 int nb_headers_found
; /**< number of headers found in the last
82 int nb_headers_buffered
; /**< number of headers that are buffered */
83 int best_header_valid
; /**< flag set when the parser returns junk;
84 if set return best_header next time */
85 AVFifoBuffer
*fifo_buf
; /**< buffer to store all data until headers
87 int end_padded
; /**< specifies if fifo_buf's end is padded */
88 uint8_t *wrap_buf
; /**< general fifo read buffer when wrapped */
89 int wrap_buf_allocated_size
; /**< actual allocated size of the buffer */
90 FLACFrameInfo last_fi
; /**< last decoded frame header info */
91 int last_fi_valid
; /**< set if last_fi is valid */
94 static int frame_header_is_valid(AVCodecContext
*avctx
, const uint8_t *buf
,
98 init_get_bits(&gb
, buf
, MAX_FRAME_HEADER_SIZE
* 8);
99 return !ff_flac_decode_frame_header(avctx
, &gb
, fi
, 127);
103 * Non-destructive fast fifo pointer fetching
104 * Returns a pointer from the specified offset.
105 * If possible the pointer points within the fifo buffer.
106 * Otherwise (if it would cause a wrap around,) a pointer to a user-specified
108 * The pointer can be NULL. In any case it will be reallocated to hold the size.
109 * If the returned pointer will be used after subsequent calls to flac_fifo_read_wrap
110 * then the subsequent calls should pass in a different wrap_buf so as to not
111 * overwrite the contents of the previous wrap_buf.
112 * This function is based on av_fifo_generic_read, which is why there is a comment
113 * about a memory barrier for SMP.
115 static uint8_t* flac_fifo_read_wrap(FLACParseContext
*fpc
, int offset
, int len
,
116 uint8_t** wrap_buf
, int* allocated_size
)
118 AVFifoBuffer
*f
= fpc
->fifo_buf
;
119 uint8_t *start
= f
->rptr
+ offset
;
123 start
-= f
->end
- f
->buffer
;
124 if (f
->end
- start
>= len
)
127 tmp_buf
= av_fast_realloc(*wrap_buf
, allocated_size
, len
);
130 av_log(fpc
->avctx
, AV_LOG_ERROR
,
131 "couldn't reallocate wrap buffer of size %d", len
);
136 int seg_len
= FFMIN(f
->end
- start
, len
);
137 memcpy(tmp_buf
, start
, seg_len
);
138 tmp_buf
= (uint8_t*)tmp_buf
+ seg_len
;
139 // memory barrier needed for SMP here in theory
141 start
+= seg_len
- (f
->end
- f
->buffer
);
149 * Return a pointer in the fifo buffer where the offset starts at until
150 * the wrap point or end of request.
151 * len will contain the valid length of the returned buffer.
152 * A second call to flac_fifo_read (with new offset and len) should be called
153 * to get the post-wrap buf if the returned len is less than the requested.
155 static uint8_t* flac_fifo_read(FLACParseContext
*fpc
, int offset
, int *len
)
157 AVFifoBuffer
*f
= fpc
->fifo_buf
;
158 uint8_t *start
= f
->rptr
+ offset
;
161 start
-= f
->end
- f
->buffer
;
162 *len
= FFMIN(*len
, f
->end
- start
);
166 static int find_headers_search_validate(FLACParseContext
*fpc
, int offset
)
171 header_buf
= flac_fifo_read_wrap(fpc
, offset
,
172 MAX_FRAME_HEADER_SIZE
,
174 &fpc
->wrap_buf_allocated_size
);
175 if (frame_header_is_valid(fpc
->avctx
, header_buf
, &fi
)) {
176 FLACHeaderMarker
**end_handle
= &fpc
->headers
;
180 while (*end_handle
) {
181 end_handle
= &(*end_handle
)->next
;
185 *end_handle
= av_mallocz(sizeof(FLACHeaderMarker
));
187 av_log(fpc
->avctx
, AV_LOG_ERROR
,
188 "couldn't allocate FLACHeaderMarker\n");
189 return AVERROR(ENOMEM
);
191 (*end_handle
)->fi
= fi
;
192 (*end_handle
)->offset
= offset
;
193 (*end_handle
)->link_penalty
= av_malloc(sizeof(int) *
194 FLAC_MAX_SEQUENTIAL_HEADERS
);
195 for (i
= 0; i
< FLAC_MAX_SEQUENTIAL_HEADERS
; i
++)
196 (*end_handle
)->link_penalty
[i
] = FLAC_HEADER_NOT_PENALIZED_YET
;
198 fpc
->nb_headers_found
++;
204 static int find_headers_search(FLACParseContext
*fpc
, uint8_t *buf
, int buf_size
,
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)
213 size
= find_headers_search_validate(fpc
, search_start
+ i
);
216 for (; i
< buf_size
- 1; i
+= 4) {
217 x
= AV_RB32(buf
+ i
);
218 if (((x
& ~(x
+ 0x01010101)) & 0x80808080)) {
219 for (j
= 0; j
< 4; j
++) {
220 if ((AV_RB16(buf
+ i
+ j
) & 0xFFFE) == 0xFFF8)
221 size
= find_headers_search_validate(fpc
, search_start
+ i
+ j
);
228 static int find_new_headers(FLACParseContext
*fpc
, int search_start
)
230 FLACHeaderMarker
*end
;
231 int search_end
, size
= 0, read_len
, temp
;
233 fpc
->nb_headers_found
= 0;
235 /* Search for a new header of at most 16 bytes. */
236 search_end
= av_fifo_size(fpc
->fifo_buf
) - (MAX_FRAME_HEADER_SIZE
- 1);
237 read_len
= search_end
- search_start
+ 1;
238 buf
= flac_fifo_read(fpc
, search_start
, &read_len
);
239 size
= find_headers_search(fpc
, buf
, read_len
, search_start
);
240 search_start
+= read_len
- 1;
242 /* If fifo end was hit do the wrap around. */
243 if (search_start
!= search_end
) {
246 wrap
[0] = buf
[read_len
- 1];
247 read_len
= search_end
- search_start
+ 1;
249 /* search_start + 1 is the post-wrap offset in the fifo. */
250 buf
= flac_fifo_read(fpc
, search_start
+ 1, &read_len
);
253 if ((AV_RB16(wrap
) & 0xFFFE) == 0xFFF8) {
254 temp
= find_headers_search_validate(fpc
, search_start
);
255 size
= FFMAX(size
, temp
);
259 /* Continue to do the last half of the wrap. */
260 temp
= find_headers_search(fpc
, buf
, read_len
, search_start
);
261 size
= FFMAX(size
, temp
);
262 search_start
+= read_len
- 1;
265 /* Return the size even if no new headers were found. */
266 if (!size
&& fpc
->headers
)
267 for (end
= fpc
->headers
; end
; end
= end
->next
)
272 static int check_header_fi_mismatch(FLACParseContext
*fpc
,
273 FLACFrameInfo
*header_fi
,
274 FLACFrameInfo
*child_fi
,
275 int log_level_offset
)
278 if (child_fi
->samplerate
!= header_fi
->samplerate
) {
279 deduction
+= FLAC_HEADER_CHANGED_PENALTY
;
280 av_log(fpc
->avctx
, AV_LOG_WARNING
+ log_level_offset
,
281 "sample rate change detected in adjacent frames\n");
283 if (child_fi
->bps
!= header_fi
->bps
) {
284 deduction
+= FLAC_HEADER_CHANGED_PENALTY
;
285 av_log(fpc
->avctx
, AV_LOG_WARNING
+ log_level_offset
,
286 "bits per sample change detected in adjacent frames\n");
288 if (child_fi
->is_var_size
!= header_fi
->is_var_size
) {
289 /* Changing blocking strategy not allowed per the spec */
290 deduction
+= FLAC_HEADER_BASE_SCORE
;
291 av_log(fpc
->avctx
, AV_LOG_WARNING
+ log_level_offset
,
292 "blocking strategy change detected in adjacent frames\n");
294 if (child_fi
->channels
!= header_fi
->channels
) {
295 deduction
+= FLAC_HEADER_CHANGED_PENALTY
;
296 av_log(fpc
->avctx
, AV_LOG_WARNING
+ log_level_offset
,
297 "number of channels change detected in adjacent frames\n");
302 static int check_header_mismatch(FLACParseContext
*fpc
,
303 FLACHeaderMarker
*header
,
304 FLACHeaderMarker
*child
,
305 int log_level_offset
)
307 FLACFrameInfo
*header_fi
= &header
->fi
, *child_fi
= &child
->fi
;
308 int deduction
, deduction_expected
= 0, i
;
309 deduction
= check_header_fi_mismatch(fpc
, header_fi
, child_fi
,
311 /* Check sample and frame numbers. */
312 if ((child_fi
->frame_or_sample_num
- header_fi
->frame_or_sample_num
313 != header_fi
->blocksize
) &&
314 (child_fi
->frame_or_sample_num
315 != header_fi
->frame_or_sample_num
+ 1)) {
316 FLACHeaderMarker
*curr
;
317 int expected_frame_num
, expected_sample_num
;
318 /* If there are frames in the middle we expect this deduction,
319 as they are probably valid and this one follows it */
321 expected_frame_num
= expected_sample_num
= header_fi
->frame_or_sample_num
;
323 while (curr
!= child
) {
324 /* Ignore frames that failed all crc checks */
325 for (i
= 0; i
< FLAC_MAX_SEQUENTIAL_HEADERS
; i
++) {
326 if (curr
->link_penalty
[i
] < FLAC_HEADER_CRC_FAIL_PENALTY
) {
327 expected_frame_num
++;
328 expected_sample_num
+= curr
->fi
.blocksize
;
335 if (expected_frame_num
== child_fi
->frame_or_sample_num
||
336 expected_sample_num
== child_fi
->frame_or_sample_num
)
337 deduction_expected
= deduction
? 0 : 1;
339 deduction
+= FLAC_HEADER_CHANGED_PENALTY
;
340 av_log(fpc
->avctx
, AV_LOG_WARNING
+ log_level_offset
,
341 "sample/frame number mismatch in adjacent frames\n");
344 /* If we have suspicious headers, check the CRC between them */
345 if (deduction
&& !deduction_expected
) {
346 FLACHeaderMarker
*curr
;
350 int inverted_test
= 0;
352 /* Since CRC is expensive only do it if we haven't yet.
353 This assumes a CRC penalty is greater than all other check penalties */
355 for (i
= 0; i
< FLAC_MAX_SEQUENTIAL_HEADERS
&& curr
!= child
; i
++)
358 if (header
->link_penalty
[i
] < FLAC_HEADER_CRC_FAIL_PENALTY
||
359 header
->link_penalty
[i
] == FLAC_HEADER_NOT_PENALIZED_YET
) {
360 FLACHeaderMarker
*start
, *end
;
362 /* Although overlapping chains are scored, the crc should never
363 have to be computed twice for a single byte. */
367 header
->link_penalty
[i
- 1] >= FLAC_HEADER_CRC_FAIL_PENALTY
) {
368 while (start
->next
!= child
)
372 header
->next
->link_penalty
[i
-1] >=
373 FLAC_HEADER_CRC_FAIL_PENALTY
) {
378 read_len
= end
->offset
- start
->offset
;
379 buf
= flac_fifo_read(fpc
, start
->offset
, &read_len
);
380 crc
= av_crc(av_crc_get_table(AV_CRC_16_ANSI
), 0, buf
, read_len
);
381 read_len
= (end
->offset
- start
->offset
) - read_len
;
384 buf
= flac_fifo_read(fpc
, end
->offset
- read_len
, &read_len
);
385 crc
= av_crc(av_crc_get_table(AV_CRC_16_ANSI
), crc
, buf
, read_len
);
389 if (!crc
^ !inverted_test
) {
390 deduction
+= FLAC_HEADER_CRC_FAIL_PENALTY
;
391 av_log(fpc
->avctx
, AV_LOG_WARNING
+ log_level_offset
,
392 "crc check failed from offset %i (frame %"PRId64
") to %i (frame %"PRId64
")\n",
393 header
->offset
, header_fi
->frame_or_sample_num
,
394 child
->offset
, child_fi
->frame_or_sample_num
);
403 * Give FLAC_HEADER_BASE_SCORE points to a frame for existing.
404 * If it has children, (subsequent frames of which the preceding CRC footer
405 * validates against this one,) then take the maximum score of the children,
406 * with a penalty of FLAC_HEADER_CHANGED_PENALTY applied for each change to
407 * bps, sample rate, channels, but not decorrelation mode, or blocksize,
408 * because it can change often.
410 static int score_header(FLACParseContext
*fpc
, FLACHeaderMarker
*header
)
412 FLACHeaderMarker
*child
;
415 int base_score
= FLAC_HEADER_BASE_SCORE
;
416 if (header
->max_score
!= FLAC_HEADER_NOT_SCORED_YET
)
417 return header
->max_score
;
419 /* Modify the base score with changes from the last output header */
420 if (fpc
->last_fi_valid
) {
421 /* Silence the log since this will be repeated if selected */
422 base_score
-= check_header_fi_mismatch(fpc
, &fpc
->last_fi
, &header
->fi
,
426 header
->max_score
= base_score
;
428 /* Check and compute the children's scores. */
429 child
= header
->next
;
430 for (dist
= 0; dist
< FLAC_MAX_SEQUENTIAL_HEADERS
&& child
; dist
++) {
431 /* Look at the child's frame header info and penalize suspicious
432 changes between the headers. */
433 if (header
->link_penalty
[dist
] == FLAC_HEADER_NOT_PENALIZED_YET
) {
434 header
->link_penalty
[dist
] = check_header_mismatch(fpc
, header
,
435 child
, AV_LOG_DEBUG
);
437 child_score
= score_header(fpc
, child
) - header
->link_penalty
[dist
];
439 if (FLAC_HEADER_BASE_SCORE
+ child_score
> header
->max_score
) {
440 /* Keep the child because the frame scoring is dynamic. */
441 header
->best_child
= child
;
442 header
->max_score
= base_score
+ child_score
;
447 return header
->max_score
;
450 static void score_sequences(FLACParseContext
*fpc
)
452 FLACHeaderMarker
*curr
;
453 int best_score
= 0;//FLAC_HEADER_NOT_SCORED_YET;
454 /* First pass to clear all old scores. */
455 for (curr
= fpc
->headers
; curr
; curr
= curr
->next
)
456 curr
->max_score
= FLAC_HEADER_NOT_SCORED_YET
;
458 /* Do a second pass to score them all. */
459 for (curr
= fpc
->headers
; curr
; curr
= curr
->next
) {
460 if (score_header(fpc
, curr
) > best_score
) {
461 fpc
->best_header
= curr
;
462 best_score
= curr
->max_score
;
467 static int get_best_header(FLACParseContext
* fpc
, const uint8_t **poutbuf
,
470 FLACHeaderMarker
*header
= fpc
->best_header
;
471 FLACHeaderMarker
*child
= header
->best_child
;
473 *poutbuf_size
= av_fifo_size(fpc
->fifo_buf
) - header
->offset
;
475 *poutbuf_size
= child
->offset
- header
->offset
;
477 /* If the child has suspicious changes, log them */
478 check_header_mismatch(fpc
, header
, child
, 0);
481 if (header
->fi
.channels
!= fpc
->avctx
->channels
||
482 !fpc
->avctx
->channel_layout
) {
483 fpc
->avctx
->channels
= header
->fi
.channels
;
484 ff_flac_set_channel_layout(fpc
->avctx
);
486 fpc
->avctx
->sample_rate
= header
->fi
.samplerate
;
487 fpc
->pc
->duration
= header
->fi
.blocksize
;
488 *poutbuf
= flac_fifo_read_wrap(fpc
, header
->offset
, *poutbuf_size
,
490 &fpc
->wrap_buf_allocated_size
);
493 if (fpc
->pc
->flags
& PARSER_FLAG_USE_CODEC_TS
){
494 if (header
->fi
.is_var_size
)
495 fpc
->pc
->pts
= header
->fi
.frame_or_sample_num
;
496 else if (header
->best_child
)
497 fpc
->pc
->pts
= header
->fi
.frame_or_sample_num
* header
->fi
.blocksize
;
500 fpc
->best_header_valid
= 0;
501 fpc
->last_fi_valid
= 1;
502 fpc
->last_fi
= header
->fi
;
504 /* Return the negative overread index so the client can compute pos.
505 This should be the amount overread to the beginning of the child */
507 return child
->offset
- av_fifo_size(fpc
->fifo_buf
);
511 static int flac_parse(AVCodecParserContext
*s
, AVCodecContext
*avctx
,
512 const uint8_t **poutbuf
, int *poutbuf_size
,
513 const uint8_t *buf
, int buf_size
)
515 FLACParseContext
*fpc
= s
->priv_data
;
516 FLACHeaderMarker
*curr
;
518 const uint8_t *read_end
= buf
;
519 const uint8_t *read_start
= buf
;
521 if (s
->flags
& PARSER_FLAG_COMPLETE_FRAMES
) {
523 if (frame_header_is_valid(avctx
, buf
, &fi
)) {
524 s
->duration
= fi
.blocksize
;
525 if (!avctx
->sample_rate
)
526 avctx
->sample_rate
= fi
.samplerate
;
527 if (fpc
->pc
->flags
& PARSER_FLAG_USE_CODEC_TS
){
528 fpc
->pc
->pts
= fi
.frame_or_sample_num
;
530 fpc
->pc
->pts
*= fi
.blocksize
;
534 *poutbuf_size
= buf_size
;
539 if (fpc
->best_header_valid
)
540 return get_best_header(fpc
, poutbuf
, poutbuf_size
);
542 /* If a best_header was found last call remove it with the buffer data. */
543 if (fpc
->best_header
&& fpc
->best_header
->best_child
) {
544 FLACHeaderMarker
*temp
;
545 FLACHeaderMarker
*best_child
= fpc
->best_header
->best_child
;
547 /* Remove headers in list until the end of the best_header. */
548 for (curr
= fpc
->headers
; curr
!= best_child
; curr
= temp
) {
549 if (curr
!= fpc
->best_header
) {
550 av_log(avctx
, AV_LOG_DEBUG
,
551 "dropping low score %i frame header from offset %i to %i\n",
552 curr
->max_score
, curr
->offset
, curr
->next
->offset
);
555 av_freep(&curr
->link_penalty
);
557 fpc
->nb_headers_buffered
--;
559 /* Release returned data from ring buffer. */
560 av_fifo_drain(fpc
->fifo_buf
, best_child
->offset
);
562 /* Fix the offset for the headers remaining to match the new buffer. */
563 for (curr
= best_child
->next
; curr
; curr
= curr
->next
)
564 curr
->offset
-= best_child
->offset
;
566 fpc
->nb_headers_buffered
--;
567 best_child
->offset
= 0;
568 fpc
->headers
= best_child
;
569 if (fpc
->nb_headers_buffered
>= FLAC_MIN_HEADERS
) {
570 fpc
->best_header
= best_child
;
571 return get_best_header(fpc
, poutbuf
, poutbuf_size
);
573 fpc
->best_header
= NULL
;
574 } else if (fpc
->best_header
) {
575 /* No end frame no need to delete the buffer; probably eof */
576 FLACHeaderMarker
*temp
;
578 for (curr
= fpc
->headers
; curr
!= fpc
->best_header
; curr
= temp
) {
580 av_freep(&curr
->link_penalty
);
583 fpc
->headers
= fpc
->best_header
->next
;
584 av_freep(&fpc
->best_header
->link_penalty
);
585 av_freep(&fpc
->best_header
);
588 /* Find and score new headers. */
589 /* buf_size is to zero when padding, so check for this since we do */
590 /* not want to try to read more input once we have found the end. */
591 /* Note that as (non-modified) parameters, buf can be non-NULL, */
592 /* while buf_size is 0. */
593 while ((buf
&& buf_size
&& read_end
< buf
+ buf_size
&&
594 fpc
->nb_headers_buffered
< FLAC_MIN_HEADERS
)
595 || ((!buf
|| !buf_size
) && !fpc
->end_padded
)) {
598 /* Pad the end once if EOF, to check the final region for headers. */
599 if (!buf
|| !buf_size
) {
601 buf_size
= MAX_FRAME_HEADER_SIZE
;
602 read_end
= read_start
+ MAX_FRAME_HEADER_SIZE
;
604 /* The maximum read size is the upper-bound of what the parser
605 needs to have the required number of frames buffered */
606 int nb_desired
= FLAC_MIN_HEADERS
- fpc
->nb_headers_buffered
+ 1;
607 read_end
= read_end
+ FFMIN(buf
+ buf_size
- read_end
,
608 nb_desired
* FLAC_AVG_FRAME_SIZE
);
611 /* Fill the buffer. */
612 if ( av_fifo_space(fpc
->fifo_buf
) < read_end
- read_start
613 && av_fifo_realloc2(fpc
->fifo_buf
, (read_end
- read_start
) + 2*av_fifo_size(fpc
->fifo_buf
)) < 0) {
614 av_log(avctx
, AV_LOG_ERROR
,
615 "couldn't reallocate buffer of size %"PTRDIFF_SPECIFIER
"\n",
616 (read_end
- read_start
) + av_fifo_size(fpc
->fifo_buf
));
620 if (buf
&& buf_size
) {
621 av_fifo_generic_write(fpc
->fifo_buf
, (void*) read_start
,
622 read_end
- read_start
, NULL
);
624 int8_t pad
[MAX_FRAME_HEADER_SIZE
] = { 0 };
625 av_fifo_generic_write(fpc
->fifo_buf
, (void*) pad
, sizeof(pad
), NULL
);
628 /* Tag headers and update sequences. */
629 start_offset
= av_fifo_size(fpc
->fifo_buf
) -
630 ((read_end
- read_start
) + (MAX_FRAME_HEADER_SIZE
- 1));
631 start_offset
= FFMAX(0, start_offset
);
632 nb_headers
= find_new_headers(fpc
, start_offset
);
634 if (nb_headers
< 0) {
635 av_log(avctx
, AV_LOG_ERROR
,
636 "find_new_headers couldn't allocate FLAC header\n");
640 fpc
->nb_headers_buffered
= nb_headers
;
641 /* Wait till FLAC_MIN_HEADERS to output a valid frame. */
642 if (!fpc
->end_padded
&& fpc
->nb_headers_buffered
< FLAC_MIN_HEADERS
) {
643 if (buf
&& read_end
< buf
+ buf_size
) {
644 read_start
= read_end
;
651 /* If headers found, update the scores since we have longer chains. */
652 if (fpc
->end_padded
|| fpc
->nb_headers_found
)
653 score_sequences(fpc
);
655 /* restore the state pre-padding */
656 if (fpc
->end_padded
) {
657 int warp
= fpc
->fifo_buf
->wptr
- fpc
->fifo_buf
->buffer
< MAX_FRAME_HEADER_SIZE
;
658 /* HACK: drain the tail of the fifo */
659 fpc
->fifo_buf
->wptr
-= MAX_FRAME_HEADER_SIZE
;
660 fpc
->fifo_buf
->wndx
-= MAX_FRAME_HEADER_SIZE
;
662 fpc
->fifo_buf
->wptr
+= fpc
->fifo_buf
->end
-
663 fpc
->fifo_buf
->buffer
;
666 read_start
= read_end
= NULL
;
670 for (curr
= fpc
->headers
; curr
; curr
= curr
->next
) {
671 if (curr
->max_score
> 0 &&
672 (!fpc
->best_header
|| curr
->max_score
> fpc
->best_header
->max_score
)) {
673 fpc
->best_header
= curr
;
677 if (fpc
->best_header
) {
678 fpc
->best_header_valid
= 1;
679 if (fpc
->best_header
->offset
> 0) {
680 /* Output a junk frame. */
681 av_log(avctx
, AV_LOG_DEBUG
, "Junk frame till offset %i\n",
682 fpc
->best_header
->offset
);
684 /* Set duration to 0. It is unknown or invalid in a junk frame. */
686 *poutbuf_size
= fpc
->best_header
->offset
;
687 *poutbuf
= flac_fifo_read_wrap(fpc
, 0, *poutbuf_size
,
689 &fpc
->wrap_buf_allocated_size
);
690 return buf_size
? (read_end
- buf
) : (fpc
->best_header
->offset
-
691 av_fifo_size(fpc
->fifo_buf
));
694 return get_best_header(fpc
, poutbuf
, poutbuf_size
);
700 return read_end
- buf
;
703 static av_cold
int flac_parse_init(AVCodecParserContext
*c
)
705 FLACParseContext
*fpc
= c
->priv_data
;
707 /* There will generally be FLAC_MIN_HEADERS buffered in the fifo before
708 it drains. This is allocated early to avoid slow reallocation. */
709 fpc
->fifo_buf
= av_fifo_alloc_array(FLAC_MIN_HEADERS
+ 3, FLAC_AVG_FRAME_SIZE
);
711 return AVERROR(ENOMEM
);
715 static void flac_parse_close(AVCodecParserContext
*c
)
717 FLACParseContext
*fpc
= c
->priv_data
;
718 FLACHeaderMarker
*curr
= fpc
->headers
, *temp
;
722 av_freep(&curr
->link_penalty
);
726 av_fifo_freep(&fpc
->fifo_buf
);
727 av_freep(&fpc
->wrap_buf
);
730 AVCodecParser ff_flac_parser
= {
731 .codec_ids
= { AV_CODEC_ID_FLAC
},
732 .priv_data_size
= sizeof(FLACParseContext
),
733 .parser_init
= flac_parse_init
,
734 .parser_parse
= flac_parse
,
735 .parser_close
= flac_parse_close
,