FFmpeg
flac_parser.c
Go to the documentation of this file.
1 /*
2  * FLAC parser
3  * Copyright (c) 2010 Michael Chinen
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 /**
23  * @file
24  * FLAC parser
25  *
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.
33  **/
34 
35 #include "libavutil/attributes.h"
36 #include "libavutil/crc.h"
37 #include "libavutil/fifo.h"
38 #include "bytestream.h"
39 #include "parser.h"
40 #include "flac.h"
41 
42 /** maximum number of adjacent headers that compare CRCs against each other */
43 #define FLAC_MAX_SEQUENTIAL_HEADERS 4
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
48 
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
55 
56 /** largest possible size of flac header */
57 #define MAX_FRAME_HEADER_SIZE 16
58 
59 typedef struct FLACHeaderMarker {
60  int offset; /**< byte offset from start of FLACParseContext->buffer */
61  int link_penalty[FLAC_MAX_SEQUENTIAL_HEADERS]; /**< array of local scores
62  between this header and the one at a distance equal
63  array position */
64  int max_score; /**< maximum score found after checking each child that
65  has a valid CRC */
66  FLACFrameInfo fi; /**< decoded frame header info */
67  struct FLACHeaderMarker *next; /**< next CRC-8 verified header that
68  immediately follows this one in
69  the bytestream */
70  struct FLACHeaderMarker *best_child; /**< following frame header with
71  which this frame has the best
72  score with */
74 
75 typedef struct FLACParseContext {
76  AVCodecParserContext *pc; /**< parent context */
77  AVCodecContext *avctx; /**< codec context pointer for logging */
78  FLACHeaderMarker *headers; /**< linked-list that starts at the first
79  CRC-8 verified header within buffer */
80  FLACHeaderMarker *best_header; /**< highest scoring header within buffer */
81  int nb_headers_found; /**< number of headers found in the last
82  flac_parse() call */
83  int nb_headers_buffered; /**< number of headers that are buffered */
84  int best_header_valid; /**< flag set when the parser returns junk;
85  if set return best_header next time */
86  AVFifoBuffer *fifo_buf; /**< buffer to store all data until headers
87  can be verified */
88  int end_padded; /**< specifies if fifo_buf's end is padded */
89  uint8_t *wrap_buf; /**< general fifo read buffer when wrapped */
90  int wrap_buf_allocated_size; /**< actual allocated size of the buffer */
91  FLACFrameInfo last_fi; /**< last decoded frame header info */
92  int last_fi_valid; /**< set if last_fi is valid */
94 
95 static int frame_header_is_valid(AVCodecContext *avctx, const uint8_t *buf,
97 {
98  GetBitContext gb;
99  init_get_bits(&gb, buf, MAX_FRAME_HEADER_SIZE * 8);
100  return !ff_flac_decode_frame_header(avctx, &gb, fi, 127);
101 }
102 
103 /**
104  * Non-destructive fast fifo pointer fetching
105  * Returns a pointer from the specified offset.
106  * If possible the pointer points within the fifo buffer.
107  * Otherwise (if it would cause a wrap around,) a pointer to a user-specified
108  * buffer is used.
109  * The pointer can be NULL. In any case it will be reallocated to hold the size.
110  * If the returned pointer will be used after subsequent calls to flac_fifo_read_wrap
111  * then the subsequent calls should pass in a different wrap_buf so as to not
112  * overwrite the contents of the previous wrap_buf.
113  * This function is based on av_fifo_generic_read, which is why there is a comment
114  * about a memory barrier for SMP.
115  */
117  uint8_t **wrap_buf, int *allocated_size)
118 {
119  AVFifoBuffer *f = fpc->fifo_buf;
120  uint8_t *start = f->rptr + offset;
121  uint8_t *tmp_buf;
122 
123  if (start >= f->end)
124  start -= f->end - f->buffer;
125  if (f->end - start >= len)
126  return start;
127 
128  tmp_buf = av_fast_realloc(*wrap_buf, allocated_size, len);
129 
130  if (!tmp_buf) {
131  av_log(fpc->avctx, AV_LOG_ERROR,
132  "couldn't reallocate wrap buffer of size %d", len);
133  return NULL;
134  }
135  *wrap_buf = tmp_buf;
136  do {
137  int seg_len = FFMIN(f->end - start, len);
138  memcpy(tmp_buf, start, seg_len);
139  tmp_buf = (uint8_t*)tmp_buf + seg_len;
140 // memory barrier needed for SMP here in theory
141 
142  start += seg_len - (f->end - f->buffer);
143  len -= seg_len;
144  } while (len > 0);
145 
146  return *wrap_buf;
147 }
148 
149 /**
150  * Return a pointer in the fifo buffer where the offset starts at until
151  * the wrap point or end of request.
152  * len will contain the valid length of the returned buffer.
153  * A second call to flac_fifo_read (with new offset and len) should be called
154  * to get the post-wrap buf if the returned len is less than the requested.
155  **/
157 {
158  AVFifoBuffer *f = fpc->fifo_buf;
159  uint8_t *start = f->rptr + offset;
160 
161  if (start >= f->end)
162  start -= f->end - f->buffer;
163  *len = FFMIN(*len, f->end - start);
164  return start;
165 }
166 
168 {
170  uint8_t *header_buf;
171  int size = 0;
172  header_buf = flac_fifo_read_wrap(fpc, offset,
174  &fpc->wrap_buf,
176  if (frame_header_is_valid(fpc->avctx, header_buf, &fi)) {
177  FLACHeaderMarker **end_handle = &fpc->headers;
178  int i;
179 
180  size = 0;
181  while (*end_handle) {
182  end_handle = &(*end_handle)->next;
183  size++;
184  }
185 
186  *end_handle = av_mallocz(sizeof(**end_handle));
187  if (!*end_handle) {
188  av_log(fpc->avctx, AV_LOG_ERROR,
189  "couldn't allocate FLACHeaderMarker\n");
190  return AVERROR(ENOMEM);
191  }
192  (*end_handle)->fi = fi;
193  (*end_handle)->offset = offset;
194 
195  for (i = 0; i < FLAC_MAX_SEQUENTIAL_HEADERS; i++)
196  (*end_handle)->link_penalty[i] = FLAC_HEADER_NOT_PENALIZED_YET;
197 
198  fpc->nb_headers_found++;
199  size++;
200  }
201  return size;
202 }
203 
205  int buf_size, int search_start)
206 {
207  int size = 0, mod_offset = (buf_size - 1) % 4, i, j;
208  uint32_t x;
209 
210  for (i = 0; i < mod_offset; i++) {
211  if ((AV_RB16(buf + i) & 0xFFFE) == 0xFFF8)
212  size = find_headers_search_validate(fpc, search_start + i);
213  }
214 
215  for (; i < buf_size - 1; i += 4) {
216  x = AV_RN32(buf + i);
217  if (((x & ~(x + 0x01010101)) & 0x80808080)) {
218  for (j = 0; j < 4; j++) {
219  if ((AV_RB16(buf + i + j) & 0xFFFE) == 0xFFF8)
220  size = find_headers_search_validate(fpc, search_start + i + j);
221  }
222  }
223  }
224  return size;
225 }
226 
227 static int find_new_headers(FLACParseContext *fpc, int search_start)
228 {
230  int search_end, size = 0, read_len, temp;
231  uint8_t *buf;
232  fpc->nb_headers_found = 0;
233 
234  /* Search for a new header of at most 16 bytes. */
235  search_end = av_fifo_size(fpc->fifo_buf) - (MAX_FRAME_HEADER_SIZE - 1);
236  read_len = search_end - search_start + 1;
237  buf = flac_fifo_read(fpc, search_start, &read_len);
238  size = find_headers_search(fpc, buf, read_len, search_start);
239  search_start += read_len - 1;
240 
241  /* If fifo end was hit do the wrap around. */
242  if (search_start != search_end) {
243  uint8_t wrap[2];
244 
245  wrap[0] = buf[read_len - 1];
246  /* search_start + 1 is the post-wrap offset in the fifo. */
247  read_len = search_end - (search_start + 1) + 1;
248 
249  buf = flac_fifo_read(fpc, search_start + 1, &read_len);
250  wrap[1] = buf[0];
251 
252  if ((AV_RB16(wrap) & 0xFFFE) == 0xFFF8) {
253  temp = find_headers_search_validate(fpc, search_start);
254  size = FFMAX(size, temp);
255  }
256  search_start++;
257 
258  /* Continue to do the last half of the wrap. */
259  temp = find_headers_search(fpc, buf, read_len, search_start);
260  size = FFMAX(size, temp);
261  search_start += read_len - 1;
262  }
263 
264  /* Return the size even if no new headers were found. */
265  if (!size && fpc->headers)
266  for (end = fpc->headers; end; end = end->next)
267  size++;
268  return size;
269 }
270 
272  FLACFrameInfo *header_fi,
273  FLACFrameInfo *child_fi,
274  int log_level_offset)
275 {
276  int deduction = 0;
277  if (child_fi->samplerate != header_fi->samplerate) {
278  deduction += FLAC_HEADER_CHANGED_PENALTY;
279  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
280  "sample rate change detected in adjacent frames\n");
281  }
282  if (child_fi->bps != header_fi->bps) {
283  deduction += FLAC_HEADER_CHANGED_PENALTY;
284  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
285  "bits per sample change detected in adjacent frames\n");
286  }
287  if (child_fi->is_var_size != header_fi->is_var_size) {
288  /* Changing blocking strategy not allowed per the spec */
289  deduction += FLAC_HEADER_BASE_SCORE;
290  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
291  "blocking strategy change detected in adjacent frames\n");
292  }
293  if (child_fi->channels != header_fi->channels) {
294  deduction += FLAC_HEADER_CHANGED_PENALTY;
295  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
296  "number of channels change detected in adjacent frames\n");
297  }
298  return deduction;
299 }
300 
304  int log_level_offset)
305 {
306  FLACFrameInfo *header_fi = &header->fi, *child_fi = &child->fi;
307  int deduction, deduction_expected = 0, i;
308  deduction = check_header_fi_mismatch(fpc, header_fi, child_fi,
309  log_level_offset);
310  /* Check sample and frame numbers. */
311  if ((child_fi->frame_or_sample_num - header_fi->frame_or_sample_num
312  != header_fi->blocksize) &&
313  (child_fi->frame_or_sample_num
314  != header_fi->frame_or_sample_num + 1)) {
315  FLACHeaderMarker *curr;
316  int64_t expected_frame_num, expected_sample_num;
317  /* If there are frames in the middle we expect this deduction,
318  as they are probably valid and this one follows it */
319 
320  expected_frame_num = expected_sample_num = header_fi->frame_or_sample_num;
321  curr = header;
322  while (curr != child) {
323  /* Ignore frames that failed all crc checks */
324  for (i = 0; i < FLAC_MAX_SEQUENTIAL_HEADERS; i++) {
326  expected_frame_num++;
327  expected_sample_num += curr->fi.blocksize;
328  break;
329  }
330  }
331  curr = curr->next;
332  }
333 
334  if (expected_frame_num == child_fi->frame_or_sample_num ||
335  expected_sample_num == child_fi->frame_or_sample_num)
336  deduction_expected = deduction ? 0 : 1;
337 
338  deduction += FLAC_HEADER_CHANGED_PENALTY;
339  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
340  "sample/frame number mismatch in adjacent frames\n");
341  }
342 
343  /* If we have suspicious headers, check the CRC between them */
344  if (deduction && !deduction_expected) {
345  FLACHeaderMarker *curr;
346  int read_len;
347  uint8_t *buf;
348  uint32_t crc = 1;
349  int inverted_test = 0;
350 
351  /* Since CRC is expensive only do it if we haven't yet.
352  This assumes a CRC penalty is greater than all other check penalties */
353  curr = header->next;
354  for (i = 0; i < FLAC_MAX_SEQUENTIAL_HEADERS && curr != child; i++)
355  curr = curr->next;
356 
360 
361  /* Although overlapping chains are scored, the crc should never
362  have to be computed twice for a single byte. */
363  start = header;
364  end = child;
365  if (i > 0 &&
366  header->link_penalty[i - 1] >= FLAC_HEADER_CRC_FAIL_PENALTY) {
367  while (start->next != child)
368  start = start->next;
369  inverted_test = 1;
370  } else if (i > 0 &&
371  header->next->link_penalty[i-1] >=
373  end = header->next;
374  inverted_test = 1;
375  }
376 
377  read_len = end->offset - start->offset;
378  buf = flac_fifo_read(fpc, start->offset, &read_len);
379  crc = av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf, read_len);
380  read_len = (end->offset - start->offset) - read_len;
381 
382  if (read_len) {
383  buf = flac_fifo_read(fpc, end->offset - read_len, &read_len);
384  crc = av_crc(av_crc_get_table(AV_CRC_16_ANSI), crc, buf, read_len);
385  }
386  }
387 
388  if (!crc ^ !inverted_test) {
389  deduction += FLAC_HEADER_CRC_FAIL_PENALTY;
390  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
391  "crc check failed from offset %i (frame %"PRId64") to %i (frame %"PRId64")\n",
392  header->offset, header_fi->frame_or_sample_num,
393  child->offset, child_fi->frame_or_sample_num);
394  }
395  }
396  return deduction;
397 }
398 
399 /**
400  * Score a header.
401  *
402  * Give FLAC_HEADER_BASE_SCORE points to a frame for existing.
403  * If it has children, (subsequent frames of which the preceding CRC footer
404  * validates against this one,) then take the maximum score of the children,
405  * with a penalty of FLAC_HEADER_CHANGED_PENALTY applied for each change to
406  * bps, sample rate, channels, but not decorrelation mode, or blocksize,
407  * because it can change often.
408  **/
410 {
412  int dist = 0;
413  int child_score;
414  int base_score = FLAC_HEADER_BASE_SCORE;
415  if (header->max_score != FLAC_HEADER_NOT_SCORED_YET)
416  return header->max_score;
417 
418  /* Modify the base score with changes from the last output header */
419  if (fpc->last_fi_valid) {
420  /* Silence the log since this will be repeated if selected */
421  base_score -= check_header_fi_mismatch(fpc, &fpc->last_fi, &header->fi,
422  AV_LOG_DEBUG);
423  }
424 
425  header->max_score = base_score;
426 
427  /* Check and compute the children's scores. */
428  child = header->next;
429  for (dist = 0; dist < FLAC_MAX_SEQUENTIAL_HEADERS && child; dist++) {
430  /* Look at the child's frame header info and penalize suspicious
431  changes between the headers. */
432  if (header->link_penalty[dist] == FLAC_HEADER_NOT_PENALIZED_YET) {
433  header->link_penalty[dist] = check_header_mismatch(fpc, header,
434  child, AV_LOG_DEBUG);
435  }
436  child_score = score_header(fpc, child) - header->link_penalty[dist];
437 
438  if (FLAC_HEADER_BASE_SCORE + child_score > header->max_score) {
439  /* Keep the child because the frame scoring is dynamic. */
440  header->best_child = child;
441  header->max_score = base_score + child_score;
442  }
443  child = child->next;
444  }
445 
446  return header->max_score;
447 }
448 
450 {
451  FLACHeaderMarker *curr;
452  int best_score = 0;//FLAC_HEADER_NOT_SCORED_YET;
453  /* First pass to clear all old scores. */
454  for (curr = fpc->headers; curr; curr = curr->next)
456 
457  /* Do a second pass to score them all. */
458  for (curr = fpc->headers; curr; curr = curr->next) {
459  if (score_header(fpc, curr) > best_score) {
460  fpc->best_header = curr;
461  best_score = curr->max_score;
462  }
463  }
464 }
465 
466 static int get_best_header(FLACParseContext *fpc, const uint8_t **poutbuf,
467  int *poutbuf_size)
468 {
470  FLACHeaderMarker *child = header->best_child;
471  if (!child) {
472  *poutbuf_size = av_fifo_size(fpc->fifo_buf) - header->offset;
473  } else {
474  *poutbuf_size = child->offset - header->offset;
475 
476  /* If the child has suspicious changes, log them */
477  check_header_mismatch(fpc, header, child, 0);
478  }
479 
480  if (header->fi.channels != fpc->avctx->channels ||
481  !fpc->avctx->channel_layout) {
482  fpc->avctx->channels = header->fi.channels;
484  }
485  fpc->avctx->sample_rate = header->fi.samplerate;
486  fpc->pc->duration = header->fi.blocksize;
487  *poutbuf = flac_fifo_read_wrap(fpc, header->offset, *poutbuf_size,
488  &fpc->wrap_buf,
490 
491 
492  if (fpc->pc->flags & PARSER_FLAG_USE_CODEC_TS) {
493  if (header->fi.is_var_size)
494  fpc->pc->pts = header->fi.frame_or_sample_num;
495  else if (header->best_child)
496  fpc->pc->pts = header->fi.frame_or_sample_num * header->fi.blocksize;
497  }
498 
499  fpc->best_header_valid = 0;
500  fpc->last_fi_valid = 1;
501  fpc->last_fi = header->fi;
502 
503  /* Return the negative overread index so the client can compute pos.
504  This should be the amount overread to the beginning of the child */
505  if (child)
506  return child->offset - av_fifo_size(fpc->fifo_buf);
507  return 0;
508 }
509 
511  const uint8_t **poutbuf, int *poutbuf_size,
512  const uint8_t *buf, int buf_size)
513 {
514  FLACParseContext *fpc = s->priv_data;
515  FLACHeaderMarker *curr;
516  int nb_headers;
517  const uint8_t *read_end = buf;
518  const uint8_t *read_start = buf;
519 
522  if (frame_header_is_valid(avctx, buf, &fi)) {
523  s->duration = fi.blocksize;
524  if (!avctx->sample_rate)
525  avctx->sample_rate = fi.samplerate;
526  if (fpc->pc->flags & PARSER_FLAG_USE_CODEC_TS) {
527  fpc->pc->pts = fi.frame_or_sample_num;
528  if (!fi.is_var_size)
529  fpc->pc->pts *= fi.blocksize;
530  }
531  }
532  *poutbuf = buf;
533  *poutbuf_size = buf_size;
534  return buf_size;
535  }
536 
537  fpc->avctx = avctx;
538  if (fpc->best_header_valid)
539  return get_best_header(fpc, poutbuf, poutbuf_size);
540 
541  /* If a best_header was found last call remove it with the buffer data. */
542  if (fpc->best_header && fpc->best_header->best_child) {
545 
546  /* Remove headers in list until the end of the best_header. */
547  for (curr = fpc->headers; curr != best_child; curr = temp) {
548  if (curr != fpc->best_header) {
549  av_log(avctx, AV_LOG_DEBUG,
550  "dropping low score %i frame header from offset %i to %i\n",
551  curr->max_score, curr->offset, curr->next->offset);
552  }
553  temp = curr->next;
554  av_free(curr);
555  fpc->nb_headers_buffered--;
556  }
557  /* Release returned data from ring buffer. */
558  av_fifo_drain(fpc->fifo_buf, best_child->offset);
559 
560  /* Fix the offset for the headers remaining to match the new buffer. */
561  for (curr = best_child->next; curr; curr = curr->next)
562  curr->offset -= best_child->offset;
563 
564  best_child->offset = 0;
565  fpc->headers = best_child;
567  fpc->best_header = best_child;
568  return get_best_header(fpc, poutbuf, poutbuf_size);
569  }
570  fpc->best_header = NULL;
571  } else if (fpc->best_header) {
572  /* No end frame no need to delete the buffer; probably eof */
574 
575  for (curr = fpc->headers; curr != fpc->best_header; curr = temp) {
576  temp = curr->next;
577  av_free(curr);
578  fpc->nb_headers_buffered--;
579  }
580  fpc->headers = fpc->best_header->next;
581  av_freep(&fpc->best_header);
582  fpc->nb_headers_buffered--;
583  }
584 
585  /* Find and score new headers. */
586  /* buf_size is zero when flushing, so check for this since we do */
587  /* not want to try to read more input once we have found the end. */
588  /* Also note that buf can't be NULL. */
589  while ((buf_size && read_end < buf + buf_size &&
591  || (!buf_size && !fpc->end_padded)) {
592  int start_offset;
593 
594  /* Pad the end once if EOF, to check the final region for headers. */
595  if (!buf_size) {
596  fpc->end_padded = 1;
597  read_end = read_start + MAX_FRAME_HEADER_SIZE;
598  } else {
599  /* The maximum read size is the upper-bound of what the parser
600  needs to have the required number of frames buffered */
601  int nb_desired = FLAC_MIN_HEADERS - fpc->nb_headers_buffered + 1;
602  read_end = read_end + FFMIN(buf + buf_size - read_end,
603  nb_desired * FLAC_AVG_FRAME_SIZE);
604  }
605 
606  if (!av_fifo_space(fpc->fifo_buf) &&
608  fpc->nb_headers_buffered * 20) {
609  /* There is less than one valid flac header buffered for 20 headers
610  * buffered. Therefore the fifo is most likely filled with invalid
611  * data and the input is not a flac file. */
612  goto handle_error;
613  }
614 
615  /* Fill the buffer. */
616  if ( av_fifo_space(fpc->fifo_buf) < read_end - read_start
617  && av_fifo_realloc2(fpc->fifo_buf, (read_end - read_start) + 2*av_fifo_size(fpc->fifo_buf)) < 0) {
618  av_log(avctx, AV_LOG_ERROR,
619  "couldn't reallocate buffer of size %"PTRDIFF_SPECIFIER"\n",
620  (read_end - read_start) + av_fifo_size(fpc->fifo_buf));
621  goto handle_error;
622  }
623 
624  if (buf_size) {
625  av_fifo_generic_write(fpc->fifo_buf, (void*) read_start,
626  read_end - read_start, NULL);
627  } else {
628  int8_t pad[MAX_FRAME_HEADER_SIZE] = { 0 };
629  av_fifo_generic_write(fpc->fifo_buf, pad, sizeof(pad), NULL);
630  }
631 
632  /* Tag headers and update sequences. */
633  start_offset = av_fifo_size(fpc->fifo_buf) -
634  ((read_end - read_start) + (MAX_FRAME_HEADER_SIZE - 1));
635  start_offset = FFMAX(0, start_offset);
636  nb_headers = find_new_headers(fpc, start_offset);
637 
638  if (nb_headers < 0) {
639  av_log(avctx, AV_LOG_ERROR,
640  "find_new_headers couldn't allocate FLAC header\n");
641  goto handle_error;
642  }
643 
644  fpc->nb_headers_buffered = nb_headers;
645  /* Wait till FLAC_MIN_HEADERS to output a valid frame. */
646  if (!fpc->end_padded && fpc->nb_headers_buffered < FLAC_MIN_HEADERS) {
647  if (read_end < buf + buf_size) {
648  read_start = read_end;
649  continue;
650  } else {
651  goto handle_error;
652  }
653  }
654 
655  /* If headers found, update the scores since we have longer chains. */
656  if (fpc->end_padded || fpc->nb_headers_found)
657  score_sequences(fpc);
658 
659  /* restore the state pre-padding */
660  if (fpc->end_padded) {
661  int warp = fpc->fifo_buf->wptr - fpc->fifo_buf->buffer < MAX_FRAME_HEADER_SIZE;
662  /* HACK: drain the tail of the fifo */
665  if (warp) {
666  fpc->fifo_buf->wptr += fpc->fifo_buf->end -
667  fpc->fifo_buf->buffer;
668  }
669  read_start = read_end = NULL;
670  }
671  }
672 
673  for (curr = fpc->headers; curr; curr = curr->next) {
674  if (!fpc->best_header || curr->max_score > fpc->best_header->max_score) {
675  fpc->best_header = curr;
676  }
677  }
678 
679  if (fpc->best_header && fpc->best_header->max_score <= 0) {
680  // Only accept a bad header if there is no other option to continue
681  if (!buf_size || read_end != buf || fpc->nb_headers_buffered < FLAC_MIN_HEADERS)
682  fpc->best_header = NULL;
683  }
684 
685  if (fpc->best_header) {
686  fpc->best_header_valid = 1;
687  if (fpc->best_header->offset > 0) {
688  /* Output a junk frame. */
689  av_log(avctx, AV_LOG_DEBUG, "Junk frame till offset %i\n",
690  fpc->best_header->offset);
691 
692  /* Set duration to 0. It is unknown or invalid in a junk frame. */
693  s->duration = 0;
694  *poutbuf_size = fpc->best_header->offset;
695  *poutbuf = flac_fifo_read_wrap(fpc, 0, *poutbuf_size,
696  &fpc->wrap_buf,
698  return buf_size ? (read_end - buf) : (fpc->best_header->offset -
699  av_fifo_size(fpc->fifo_buf));
700  }
701  if (!buf_size)
702  return get_best_header(fpc, poutbuf, poutbuf_size);
703  }
704 
705 handle_error:
706  *poutbuf = NULL;
707  *poutbuf_size = 0;
708  return buf_size ? read_end - buf : 0;
709 }
710 
712 {
713  FLACParseContext *fpc = c->priv_data;
714  fpc->pc = c;
715  /* There will generally be FLAC_MIN_HEADERS buffered in the fifo before
716  it drains. This is allocated early to avoid slow reallocation. */
718  if (!fpc->fifo_buf) {
719  av_log(fpc->avctx, AV_LOG_ERROR,
720  "couldn't allocate fifo_buf\n");
721  return AVERROR(ENOMEM);
722  }
723  return 0;
724 }
725 
727 {
728  FLACParseContext *fpc = c->priv_data;
729  FLACHeaderMarker *curr = fpc->headers, *temp;
730 
731  while (curr) {
732  temp = curr->next;
733  av_free(curr);
734  curr = temp;
735  }
736  fpc->headers = NULL;
737  av_fifo_freep(&fpc->fifo_buf);
738  av_freep(&fpc->wrap_buf);
739 }
740 
743  .priv_data_size = sizeof(FLACParseContext),
744  .parser_init = flac_parse_init,
745  .parser_parse = flac_parse,
746  .parser_close = flac_parse_close,
747 };
static int frame_header_is_valid(AVCodecContext *avctx, const uint8_t *buf, FLACFrameInfo *fi)
Definition: flac_parser.c:95
#define NULL
Definition: coverity.c:32
static void score_sequences(FLACParseContext *fpc)
Definition: flac_parser.c:449
uint8_t * wptr
Definition: fifo.h:33
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
else temp
Definition: vf_mcdeint.c:256
int64_t frame_or_sample_num
frame number or sample number
Definition: flac.h:88
int codec_ids[5]
Definition: avcodec.h:5287
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
AVFifoBuffer * fifo_buf
buffer to store all data until headers can be verified
Definition: flac_parser.c:86
int duration
Duration of the current frame.
Definition: avcodec.h:5241
#define FLAC_HEADER_CRC_FAIL_PENALTY
Definition: flac_parser.c:52
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:87
FLACCOMMONINFO int blocksize
block size of the frame
Definition: flac.h:86
Macro definitions for various function/variable attributes.
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.
Definition: fifo.c:122
AVCodecContext * avctx
codec context pointer for logging
Definition: flac_parser.c:77
int best_header_valid
flag set when the parser returns junk; if set return best_header next time
Definition: flac_parser.c:84
#define FLAC_AVG_FRAME_SIZE
estimate for average size of a FLAC frame
Definition: flac_parser.c:47
FLACFrameInfo last_fi
last decoded frame header info
Definition: flac_parser.c:91
uint8_t
#define av_cold
Definition: attributes.h:82
int nb_headers_found
number of headers found in the last flac_parse() call
Definition: flac_parser.c:81
#define f(width, name)
Definition: cbs_vp9.c:255
AVS_FilterInfo AVS_Value child
Definition: avisynth_c.h:807
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
int wrap_buf_allocated_size
actual allocated size of the buffer
Definition: flac_parser.c:90
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...
Definition: fifo.c:82
#define FLAC_HEADER_NOT_SCORED_YET
Definition: flac_parser.c:54
Public header for CRC hash function implementation.
static int get_best_header(FLACParseContext *fpc, const uint8_t **poutbuf, int *poutbuf_size)
Definition: flac_parser.c:466
#define FLAC_HEADER_CHANGED_PENALTY
Definition: flac_parser.c:51
static void flac_parse_close(AVCodecParserContext *c)
Definition: flac_parser.c:726
#define FLAC_MAX_SEQUENTIAL_HEADERS
maximum number of adjacent headers that compare CRCs against each other
Definition: flac_parser.c:43
ptrdiff_t size
Definition: opengl_enc.c:100
static const uint8_t header[24]
Definition: sdr2.c:67
static int flac_parse(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size)
Definition: flac_parser.c:510
#define av_log(a,...)
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define PTRDIFF_SPECIFIER
Definition: internal.h:261
static int check_header_fi_mismatch(FLACParseContext *fpc, FLACFrameInfo *header_fi, FLACFrameInfo *child_fi, int log_level_offset)
Definition: flac_parser.c:271
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
#define wrap(func)
Definition: neontest.h:65
#define FFMAX(a, b)
Definition: common.h:94
int ff_flac_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, FLACFrameInfo *fi, int log_level_offset)
Validate and decode a frame header.
Definition: flac.c:50
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2279
int end_padded
specifies if fifo_buf&#39;s end is padded
Definition: flac_parser.c:88
struct FLACHeaderMarker * next
next CRC-8 verified header that immediately follows this one in the bytestream
Definition: flac_parser.c:67
#define FFMIN(a, b)
Definition: common.h:96
FLACHeaderMarker * headers
linked-list that starts at the first CRC-8 verified header within buffer
Definition: flac_parser.c:78
#define FLAC_MIN_HEADERS
minimum number of headers buffered and checked before returning frames
Definition: flac_parser.c:45
uint8_t * end
Definition: fifo.h:33
uint8_t * rptr
Definition: fifo.h:33
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
#define s(width, name)
Definition: cbs_vp9.c:257
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.
Definition: mem.c:476
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.
Definition: flac_parser.c:116
int last_fi_valid
set if last_fi is valid
Definition: flac_parser.c:92
if(ret)
int max_score
maximum score found after checking each child that has a valid CRC
Definition: flac_parser.c:64
static int find_headers_search_validate(FLACParseContext *fpc, int offset)
Definition: flac_parser.c:167
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 ...
Definition: fifo.c:77
uint8_t * wrap_buf
general fifo read buffer when wrapped
Definition: flac_parser.c:89
int sample_rate
samples per second
Definition: avcodec.h:2228
int av_fifo_realloc2(AVFifoBuffer *f, unsigned int new_size)
Resize an AVFifoBuffer.
Definition: fifo.c:87
#define FLAC_HEADER_NOT_PENALIZED_YET
Definition: flac_parser.c:53
main external API structure.
Definition: avcodec.h:1568
a very simple circular buffer FIFO implementation
static int find_new_headers(FLACParseContext *fpc, int search_start)
Definition: flac_parser.c:227
void * buf
Definition: avisynth_c.h:766
void ff_flac_set_channel_layout(AVCodecContext *avctx)
Definition: flac.c:196
uint8_t * buffer
Definition: fifo.h:32
static int score_header(FLACParseContext *fpc, FLACHeaderMarker *header)
Score a header.
Definition: flac_parser.c:409
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
FLACFrameInfo fi
decoded frame header info
Definition: flac_parser.c:66
#define AV_RN32(p)
Definition: intreadwrite.h:364
int nb_headers_buffered
number of headers that are buffered
Definition: flac_parser.c:83
#define MAX_FRAME_HEADER_SIZE
largest possible size of flac header
Definition: flac_parser.c:57
uint32_t wndx
Definition: fifo.h:34
AVCodecParserContext * pc
parent context
Definition: flac_parser.c:76
FLACHeaderMarker * best_header
highest scoring header within buffer
Definition: flac_parser.c:80
AVFifoBuffer * av_fifo_alloc_array(size_t nmemb, size_t size)
Initialize an AVFifoBuffer.
Definition: fifo.c:49
AVCodecParser ff_flac_parser
Definition: flac_parser.c:741
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
static int find_headers_search(FLACParseContext *fpc, uint8_t *buf, int buf_size, int search_start)
Definition: flac_parser.c:204
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:5153
int offset
byte offset from start of FLACParseContext->buffer
Definition: flac_parser.c:60
#define av_free(p)
int len
int channels
number of audio channels
Definition: avcodec.h:2229
static av_cold int flac_parse_init(AVCodecParserContext *c)
Definition: flac_parser.c:711
#define FLAC_HEADER_BASE_SCORE
scoring settings for score_header
Definition: flac_parser.c:50
int is_var_size
specifies if the stream uses variable block sizes or a fixed block size; also determines the meaning ...
Definition: flac.h:89
int link_penalty[FLAC_MAX_SEQUENTIAL_HEADERS]
array of local scores between this header and the one at a distance equal array position ...
Definition: flac_parser.c:61
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...
Definition: flac_parser.c:156
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:766
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
Definition: fifo.c:63
struct FLACHeaderMarker * best_child
following frame header with which this frame has the best score with
Definition: flac_parser.c:70
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
void av_fifo_drain(AVFifoBuffer *f, int size)
Discard data from the FIFO.
Definition: fifo.c:233
#define PARSER_FLAG_USE_CODEC_TS
Definition: avcodec.h:5157
static int check_header_mismatch(FLACParseContext *fpc, FLACHeaderMarker *header, FLACHeaderMarker *child, int log_level_offset)
Definition: flac_parser.c:301