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,
96  FLACFrameInfo *fi)
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 {
169  FLACFrameInfo fi;
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  int ret = find_headers_search_validate(fpc, search_start + i);
213  size = FFMAX(size, ret);
214  }
215  }
216 
217  for (; i < buf_size - 1; i += 4) {
218  x = AV_RN32(buf + i);
219  if (((x & ~(x + 0x01010101)) & 0x80808080)) {
220  for (j = 0; j < 4; j++) {
221  if ((AV_RB16(buf + i + j) & 0xFFFE) == 0xFFF8) {
222  int ret = find_headers_search_validate(fpc, search_start + i + j);
223  size = FFMAX(size, ret);
224  }
225  }
226  }
227  }
228  return size;
229 }
230 
231 static int find_new_headers(FLACParseContext *fpc, int search_start)
232 {
233  FLACHeaderMarker *end;
234  int search_end, size = 0, read_len, temp;
235  uint8_t *buf;
236  fpc->nb_headers_found = 0;
237 
238  /* Search for a new header of at most 16 bytes. */
239  search_end = av_fifo_size(fpc->fifo_buf) - (MAX_FRAME_HEADER_SIZE - 1);
240  read_len = search_end - search_start + 1;
241  buf = flac_fifo_read(fpc, search_start, &read_len);
242  size = find_headers_search(fpc, buf, read_len, search_start);
243  search_start += read_len - 1;
244 
245  /* If fifo end was hit do the wrap around. */
246  if (search_start != search_end) {
247  uint8_t wrap[2];
248 
249  wrap[0] = buf[read_len - 1];
250  /* search_start + 1 is the post-wrap offset in the fifo. */
251  read_len = search_end - (search_start + 1) + 1;
252 
253  buf = flac_fifo_read(fpc, search_start + 1, &read_len);
254  wrap[1] = buf[0];
255 
256  if ((AV_RB16(wrap) & 0xFFFE) == 0xFFF8) {
257  temp = find_headers_search_validate(fpc, search_start);
258  size = FFMAX(size, temp);
259  }
260  search_start++;
261 
262  /* Continue to do the last half of the wrap. */
263  temp = find_headers_search(fpc, buf, read_len, search_start);
264  size = FFMAX(size, temp);
265  search_start += read_len - 1;
266  }
267 
268  /* Return the size even if no new headers were found. */
269  if (!size && fpc->headers)
270  for (end = fpc->headers; end; end = end->next)
271  size++;
272  return size;
273 }
274 
276  FLACFrameInfo *header_fi,
277  FLACFrameInfo *child_fi,
278  int log_level_offset)
279 {
280  int deduction = 0;
281  if (child_fi->samplerate != header_fi->samplerate) {
282  deduction += FLAC_HEADER_CHANGED_PENALTY;
283  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
284  "sample rate change detected in adjacent frames\n");
285  }
286  if (child_fi->bps != header_fi->bps) {
287  deduction += FLAC_HEADER_CHANGED_PENALTY;
288  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
289  "bits per sample change detected in adjacent frames\n");
290  }
291  if (child_fi->is_var_size != header_fi->is_var_size) {
292  /* Changing blocking strategy not allowed per the spec */
293  deduction += FLAC_HEADER_BASE_SCORE;
294  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
295  "blocking strategy change detected in adjacent frames\n");
296  }
297  if (child_fi->channels != header_fi->channels) {
298  deduction += FLAC_HEADER_CHANGED_PENALTY;
299  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
300  "number of channels change detected in adjacent frames\n");
301  }
302  return deduction;
303 }
304 
307  FLACHeaderMarker *child,
308  int log_level_offset)
309 {
310  FLACFrameInfo *header_fi = &header->fi, *child_fi = &child->fi;
311  int deduction, deduction_expected = 0, i;
312  deduction = check_header_fi_mismatch(fpc, header_fi, child_fi,
313  log_level_offset);
314  /* Check sample and frame numbers. */
315  if ((child_fi->frame_or_sample_num - header_fi->frame_or_sample_num
316  != header_fi->blocksize) &&
317  (child_fi->frame_or_sample_num
318  != header_fi->frame_or_sample_num + 1)) {
319  FLACHeaderMarker *curr;
320  int64_t expected_frame_num, expected_sample_num;
321  /* If there are frames in the middle we expect this deduction,
322  as they are probably valid and this one follows it */
323 
324  expected_frame_num = expected_sample_num = header_fi->frame_or_sample_num;
325  curr = header;
326  while (curr != child) {
327  /* Ignore frames that failed all crc checks */
328  for (i = 0; i < FLAC_MAX_SEQUENTIAL_HEADERS; i++) {
330  expected_frame_num++;
331  expected_sample_num += curr->fi.blocksize;
332  break;
333  }
334  }
335  curr = curr->next;
336  }
337 
338  if (expected_frame_num == child_fi->frame_or_sample_num ||
339  expected_sample_num == child_fi->frame_or_sample_num)
340  deduction_expected = deduction ? 0 : 1;
341 
342  deduction += FLAC_HEADER_CHANGED_PENALTY;
343  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
344  "sample/frame number mismatch in adjacent frames\n");
345  }
346 
347  /* If we have suspicious headers, check the CRC between them */
348  if (deduction && !deduction_expected) {
349  FLACHeaderMarker *curr;
350  int read_len;
351  uint8_t *buf;
352  uint32_t crc = 1;
353  int inverted_test = 0;
354 
355  /* Since CRC is expensive only do it if we haven't yet.
356  This assumes a CRC penalty is greater than all other check penalties */
357  curr = header->next;
358  for (i = 0; i < FLAC_MAX_SEQUENTIAL_HEADERS && curr != child; i++)
359  curr = curr->next;
360 
361  if (header->link_penalty[i] < FLAC_HEADER_CRC_FAIL_PENALTY ||
362  header->link_penalty[i] == FLAC_HEADER_NOT_PENALIZED_YET) {
363  FLACHeaderMarker *start, *end;
364 
365  /* Although overlapping chains are scored, the crc should never
366  have to be computed twice for a single byte. */
367  start = header;
368  end = child;
369  if (i > 0 &&
370  header->link_penalty[i - 1] >= FLAC_HEADER_CRC_FAIL_PENALTY) {
371  while (start->next != child)
372  start = start->next;
373  inverted_test = 1;
374  } else if (i > 0 &&
375  header->next->link_penalty[i-1] >=
377  end = header->next;
378  inverted_test = 1;
379  }
380 
381  read_len = end->offset - start->offset;
382  buf = flac_fifo_read(fpc, start->offset, &read_len);
383  crc = av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf, read_len);
384  read_len = (end->offset - start->offset) - read_len;
385 
386  if (read_len) {
387  buf = flac_fifo_read(fpc, end->offset - read_len, &read_len);
388  crc = av_crc(av_crc_get_table(AV_CRC_16_ANSI), crc, buf, read_len);
389  }
390  }
391 
392  if (!crc ^ !inverted_test) {
393  deduction += FLAC_HEADER_CRC_FAIL_PENALTY;
394  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
395  "crc check failed from offset %i (frame %"PRId64") to %i (frame %"PRId64")\n",
396  header->offset, header_fi->frame_or_sample_num,
397  child->offset, child_fi->frame_or_sample_num);
398  }
399  }
400  return deduction;
401 }
402 
403 /**
404  * Score a header.
405  *
406  * Give FLAC_HEADER_BASE_SCORE points to a frame for existing.
407  * If it has children, (subsequent frames of which the preceding CRC footer
408  * validates against this one,) then take the maximum score of the children,
409  * with a penalty of FLAC_HEADER_CHANGED_PENALTY applied for each change to
410  * bps, sample rate, channels, but not decorrelation mode, or blocksize,
411  * because it can change often.
412  **/
414 {
415  FLACHeaderMarker *child;
416  int dist = 0;
417  int child_score;
418  int base_score = FLAC_HEADER_BASE_SCORE;
419  if (header->max_score != FLAC_HEADER_NOT_SCORED_YET)
420  return header->max_score;
421 
422  /* Modify the base score with changes from the last output header */
423  if (fpc->last_fi_valid) {
424  /* Silence the log since this will be repeated if selected */
425  base_score -= check_header_fi_mismatch(fpc, &fpc->last_fi, &header->fi,
426  AV_LOG_DEBUG);
427  }
428 
429  header->max_score = base_score;
430 
431  /* Check and compute the children's scores. */
432  child = header->next;
433  for (dist = 0; dist < FLAC_MAX_SEQUENTIAL_HEADERS && child; dist++) {
434  /* Look at the child's frame header info and penalize suspicious
435  changes between the headers. */
436  if (header->link_penalty[dist] == FLAC_HEADER_NOT_PENALIZED_YET) {
437  header->link_penalty[dist] = check_header_mismatch(fpc, header,
438  child, AV_LOG_DEBUG);
439  }
440  child_score = score_header(fpc, child) - header->link_penalty[dist];
441 
442  if (FLAC_HEADER_BASE_SCORE + child_score > header->max_score) {
443  /* Keep the child because the frame scoring is dynamic. */
444  header->best_child = child;
445  header->max_score = base_score + child_score;
446  }
447  child = child->next;
448  }
449 
450  return header->max_score;
451 }
452 
454 {
455  FLACHeaderMarker *curr;
456  int best_score = 0;//FLAC_HEADER_NOT_SCORED_YET;
457  /* First pass to clear all old scores. */
458  for (curr = fpc->headers; curr; curr = curr->next)
460 
461  /* Do a second pass to score them all. */
462  for (curr = fpc->headers; curr; curr = curr->next) {
463  if (score_header(fpc, curr) > best_score) {
464  fpc->best_header = curr;
465  best_score = curr->max_score;
466  }
467  }
468 }
469 
470 static int get_best_header(FLACParseContext *fpc, const uint8_t **poutbuf,
471  int *poutbuf_size)
472 {
474  FLACHeaderMarker *child = header->best_child;
475  if (!child) {
476  *poutbuf_size = av_fifo_size(fpc->fifo_buf) - header->offset;
477  } else {
478  *poutbuf_size = child->offset - header->offset;
479 
480  /* If the child has suspicious changes, log them */
481  check_header_mismatch(fpc, header, child, 0);
482  }
483 
484  if (header->fi.channels != fpc->avctx->channels ||
485  !fpc->avctx->channel_layout) {
486  fpc->avctx->channels = header->fi.channels;
488  }
489  fpc->avctx->sample_rate = header->fi.samplerate;
490  fpc->pc->duration = header->fi.blocksize;
491  *poutbuf = flac_fifo_read_wrap(fpc, header->offset, *poutbuf_size,
492  &fpc->wrap_buf,
494 
495 
496  if (fpc->pc->flags & PARSER_FLAG_USE_CODEC_TS) {
497  if (header->fi.is_var_size)
498  fpc->pc->pts = header->fi.frame_or_sample_num;
499  else if (header->best_child)
500  fpc->pc->pts = header->fi.frame_or_sample_num * header->fi.blocksize;
501  }
502 
503  fpc->best_header_valid = 0;
504  fpc->last_fi_valid = 1;
505  fpc->last_fi = header->fi;
506 
507  /* Return the negative overread index so the client can compute pos.
508  This should be the amount overread to the beginning of the child */
509  if (child)
510  return child->offset - av_fifo_size(fpc->fifo_buf);
511  return 0;
512 }
513 
515  const uint8_t **poutbuf, int *poutbuf_size,
516  const uint8_t *buf, int buf_size)
517 {
518  FLACParseContext *fpc = s->priv_data;
519  FLACHeaderMarker *curr;
520  int nb_headers;
521  const uint8_t *read_end = buf;
522  const uint8_t *read_start = buf;
523 
524  if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
525  FLACFrameInfo fi;
526  if (frame_header_is_valid(avctx, buf, &fi)) {
527  s->duration = fi.blocksize;
528  if (!avctx->sample_rate)
529  avctx->sample_rate = fi.samplerate;
530  if (fpc->pc->flags & PARSER_FLAG_USE_CODEC_TS) {
531  fpc->pc->pts = fi.frame_or_sample_num;
532  if (!fi.is_var_size)
533  fpc->pc->pts *= fi.blocksize;
534  }
535  }
536  *poutbuf = buf;
537  *poutbuf_size = buf_size;
538  return buf_size;
539  }
540 
541  fpc->avctx = avctx;
542  if (fpc->best_header_valid)
543  return get_best_header(fpc, poutbuf, poutbuf_size);
544 
545  /* If a best_header was found last call remove it with the buffer data. */
546  if (fpc->best_header && fpc->best_header->best_child) {
548  FLACHeaderMarker *best_child = fpc->best_header->best_child;
549 
550  /* Remove headers in list until the end of the best_header. */
551  for (curr = fpc->headers; curr != best_child; curr = temp) {
552  if (curr != fpc->best_header) {
553  av_log(avctx, AV_LOG_DEBUG,
554  "dropping low score %i frame header from offset %i to %i\n",
555  curr->max_score, curr->offset, curr->next->offset);
556  }
557  temp = curr->next;
558  av_free(curr);
559  fpc->nb_headers_buffered--;
560  }
561  /* Release returned data from ring buffer. */
562  av_fifo_drain(fpc->fifo_buf, best_child->offset);
563 
564  /* Fix the offset for the headers remaining to match the new buffer. */
565  for (curr = best_child->next; curr; curr = curr->next)
566  curr->offset -= best_child->offset;
567 
568  best_child->offset = 0;
569  fpc->headers = best_child;
571  fpc->best_header = best_child;
572  return get_best_header(fpc, poutbuf, poutbuf_size);
573  }
574  fpc->best_header = NULL;
575  } else if (fpc->best_header) {
576  /* No end frame no need to delete the buffer; probably eof */
578 
579  for (curr = fpc->headers; curr != fpc->best_header; curr = temp) {
580  temp = curr->next;
581  av_free(curr);
582  fpc->nb_headers_buffered--;
583  }
584  fpc->headers = fpc->best_header->next;
585  av_freep(&fpc->best_header);
586  fpc->nb_headers_buffered--;
587  }
588 
589  /* Find and score new headers. */
590  /* buf_size is zero when flushing, so check for this since we do */
591  /* not want to try to read more input once we have found the end. */
592  /* Also note that buf can't be NULL. */
593  while ((buf_size && read_end < buf + buf_size &&
595  || (!buf_size && !fpc->end_padded)) {
596  int start_offset;
597 
598  /* Pad the end once if EOF, to check the final region for headers. */
599  if (!buf_size) {
600  fpc->end_padded = 1;
601  read_end = read_start + MAX_FRAME_HEADER_SIZE;
602  } else {
603  /* The maximum read size is the upper-bound of what the parser
604  needs to have the required number of frames buffered */
605  int nb_desired = FLAC_MIN_HEADERS - fpc->nb_headers_buffered + 1;
606  read_end = read_end + FFMIN(buf + buf_size - read_end,
607  nb_desired * FLAC_AVG_FRAME_SIZE);
608  }
609 
610  if (!av_fifo_space(fpc->fifo_buf) &&
612  fpc->nb_headers_buffered * 20) {
613  /* There is less than one valid flac header buffered for 20 headers
614  * buffered. Therefore the fifo is most likely filled with invalid
615  * data and the input is not a flac file. */
616  goto handle_error;
617  }
618 
619  /* Fill the buffer. */
620  if ( av_fifo_space(fpc->fifo_buf) < read_end - read_start
621  && av_fifo_realloc2(fpc->fifo_buf, (read_end - read_start) + 2*av_fifo_size(fpc->fifo_buf)) < 0) {
622  av_log(avctx, AV_LOG_ERROR,
623  "couldn't reallocate buffer of size %"PTRDIFF_SPECIFIER"\n",
624  (read_end - read_start) + av_fifo_size(fpc->fifo_buf));
625  goto handle_error;
626  }
627 
628  if (buf_size) {
629  av_fifo_generic_write(fpc->fifo_buf, (void*) read_start,
630  read_end - read_start, NULL);
631  } else {
632  int8_t pad[MAX_FRAME_HEADER_SIZE] = { 0 };
633  av_fifo_generic_write(fpc->fifo_buf, pad, sizeof(pad), NULL);
634  }
635 
636  /* Tag headers and update sequences. */
637  start_offset = av_fifo_size(fpc->fifo_buf) -
638  ((read_end - read_start) + (MAX_FRAME_HEADER_SIZE - 1));
639  start_offset = FFMAX(0, start_offset);
640  nb_headers = find_new_headers(fpc, start_offset);
641 
642  if (nb_headers < 0) {
643  av_log(avctx, AV_LOG_ERROR,
644  "find_new_headers couldn't allocate FLAC header\n");
645  goto handle_error;
646  }
647 
648  fpc->nb_headers_buffered = nb_headers;
649  /* Wait till FLAC_MIN_HEADERS to output a valid frame. */
650  if (!fpc->end_padded && fpc->nb_headers_buffered < FLAC_MIN_HEADERS) {
651  if (read_end < buf + buf_size) {
652  read_start = read_end;
653  continue;
654  } else {
655  goto handle_error;
656  }
657  }
658 
659  /* If headers found, update the scores since we have longer chains. */
660  if (fpc->end_padded || fpc->nb_headers_found)
661  score_sequences(fpc);
662 
663  /* restore the state pre-padding */
664  if (fpc->end_padded) {
665  int warp = fpc->fifo_buf->wptr - fpc->fifo_buf->buffer < MAX_FRAME_HEADER_SIZE;
666  /* HACK: drain the tail of the fifo */
669  if (warp) {
670  fpc->fifo_buf->wptr += fpc->fifo_buf->end -
671  fpc->fifo_buf->buffer;
672  }
673  read_start = read_end = NULL;
674  }
675  }
676 
677  for (curr = fpc->headers; curr; curr = curr->next) {
678  if (!fpc->best_header || curr->max_score > fpc->best_header->max_score) {
679  fpc->best_header = curr;
680  }
681  }
682 
683  if (fpc->best_header && fpc->best_header->max_score <= 0) {
684  // Only accept a bad header if there is no other option to continue
685  if (!buf_size || read_end != buf || fpc->nb_headers_buffered < FLAC_MIN_HEADERS)
686  fpc->best_header = NULL;
687  }
688 
689  if (fpc->best_header) {
690  fpc->best_header_valid = 1;
691  if (fpc->best_header->offset > 0) {
692  /* Output a junk frame. */
693  av_log(avctx, AV_LOG_DEBUG, "Junk frame till offset %i\n",
694  fpc->best_header->offset);
695 
696  /* Set duration to 0. It is unknown or invalid in a junk frame. */
697  s->duration = 0;
698  *poutbuf_size = fpc->best_header->offset;
699  *poutbuf = flac_fifo_read_wrap(fpc, 0, *poutbuf_size,
700  &fpc->wrap_buf,
702  return buf_size ? (read_end - buf) : (fpc->best_header->offset -
703  av_fifo_size(fpc->fifo_buf));
704  }
705  if (!buf_size)
706  return get_best_header(fpc, poutbuf, poutbuf_size);
707  }
708 
709 handle_error:
710  *poutbuf = NULL;
711  *poutbuf_size = 0;
712  return buf_size ? read_end - buf : 0;
713 }
714 
716 {
717  FLACParseContext *fpc = c->priv_data;
718  fpc->pc = c;
719  /* There will generally be FLAC_MIN_HEADERS buffered in the fifo before
720  it drains. This is allocated early to avoid slow reallocation. */
722  if (!fpc->fifo_buf) {
723  av_log(fpc->avctx, AV_LOG_ERROR,
724  "couldn't allocate fifo_buf\n");
725  return AVERROR(ENOMEM);
726  }
727  return 0;
728 }
729 
731 {
732  FLACParseContext *fpc = c->priv_data;
733  FLACHeaderMarker *curr = fpc->headers, *temp;
734 
735  while (curr) {
736  temp = curr->next;
737  av_free(curr);
738  curr = temp;
739  }
740  fpc->headers = NULL;
741  av_fifo_freep(&fpc->fifo_buf);
742  av_freep(&fpc->wrap_buf);
743 }
744 
747  .priv_data_size = sizeof(FLACParseContext),
748  .parser_init = flac_parse_init,
749  .parser_parse = flac_parse,
750  .parser_close = flac_parse_close,
751 };
FLACParseContext
Definition: flac_parser.c:75
FLACParseContext::headers
FLACHeaderMarker * headers
linked-list that starts at the first CRC-8 verified header within buffer
Definition: flac_parser.c:78
FLAC_HEADER_BASE_SCORE
#define FLAC_HEADER_BASE_SCORE
scoring settings for score_header
Definition: flac_parser.c:50
frame_header_is_valid
static int frame_header_is_valid(AVCodecContext *avctx, const uint8_t *buf, FLACFrameInfo *fi)
Definition: flac_parser.c:95
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
check_header_fi_mismatch
static int check_header_fi_mismatch(FLACParseContext *fpc, FLACFrameInfo *header_fi, FLACFrameInfo *child_fi, int log_level_offset)
Definition: flac_parser.c:275
FLACParseContext::nb_headers_buffered
int nb_headers_buffered
number of headers that are buffered
Definition: flac_parser.c:83
AVCodecParserContext::pts
int64_t pts
Definition: avcodec.h:3396
find_new_headers
static int find_new_headers(FLACParseContext *fpc, int search_start)
Definition: flac_parser.c:231
FLACHeaderMarker
Definition: flac_parser.c:59
AVERROR
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
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
av_fifo_generic_write
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::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1196
AVCodecParserContext::duration
int duration
Duration of the current frame.
Definition: avcodec.h:3499
AVFifoBuffer::wptr
uint8_t * wptr
Definition: fifo.h:33
FLACParseContext::wrap_buf
uint8_t * wrap_buf
general fifo read buffer when wrapped
Definition: flac_parser.c:89
FLACHeaderMarker::best_child
struct FLACHeaderMarker * best_child
following frame header with which this frame has the best score with
Definition: flac_parser.c:70
FLACFrameInfo::frame_or_sample_num
int64_t frame_or_sample_num
frame number or sample number
Definition: flac.h:88
FLACFrameInfo::is_var_size
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
score_sequences
static void score_sequences(FLACParseContext *fpc)
Definition: flac_parser.c:453
ff_flac_decode_frame_header
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
AV_CODEC_ID_FLAC
@ AV_CODEC_ID_FLAC
Definition: codec_id.h:436
FLAC_HEADER_CHANGED_PENALTY
#define FLAC_HEADER_CHANGED_PENALTY
Definition: flac_parser.c:51
FLAC_MAX_SEQUENTIAL_HEADERS
#define FLAC_MAX_SEQUENTIAL_HEADERS
maximum number of adjacent headers that compare CRCs against each other
Definition: flac_parser.c:43
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
FLACParseContext::wrap_buf_allocated_size
int wrap_buf_allocated_size
actual allocated size of the buffer
Definition: flac_parser.c:90
av_fifo_drain
void av_fifo_drain(AVFifoBuffer *f, int size)
Discard data from the FIFO.
Definition: fifo.c:233
AVFifoBuffer
Definition: fifo.h:31
crc.h
flac_fifo_read_wrap
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
fifo.h
wrap
#define wrap(func)
Definition: neontest.h:65
FLACParseContext::fifo_buf
AVFifoBuffer * fifo_buf
buffer to store all data until headers can be verified
Definition: flac_parser.c:86
GetBitContext
Definition: get_bits.h:61
FLACParseContext::best_header_valid
int best_header_valid
flag set when the parser returns junk; if set return best_header next time
Definition: flac_parser.c:84
flac_fifo_read
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
get_best_header
static int get_best_header(FLACParseContext *fpc, const uint8_t **poutbuf, int *poutbuf_size)
Definition: flac_parser.c:470
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
av_fifo_space
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
av_cold
#define av_cold
Definition: attributes.h:90
FLACHeaderMarker::next
struct FLACHeaderMarker * next
next CRC-8 verified header that immediately follows this one in the bytestream
Definition: flac_parser.c:67
av_fast_realloc
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:478
FLAC_AVG_FRAME_SIZE
#define FLAC_AVG_FRAME_SIZE
estimate for average size of a FLAC frame
Definition: flac_parser.c:47
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
FLACParseContext::last_fi_valid
int last_fi_valid
set if last_fi is valid
Definition: flac_parser.c:92
FLACParseContext::avctx
AVCodecContext * avctx
codec context pointer for logging
Definition: flac_parser.c:77
find_headers_search_validate
static int find_headers_search_validate(FLACParseContext *fpc, int offset)
Definition: flac_parser.c:167
FLACParseContext::pc
AVCodecParserContext * pc
parent context
Definition: flac_parser.c:76
av_fifo_realloc2
int av_fifo_realloc2(AVFifoBuffer *f, unsigned int new_size)
Resize an AVFifoBuffer.
Definition: fifo.c:87
f
#define f(width, name)
Definition: cbs_vp9.c:255
ff_flac_parser
AVCodecParser ff_flac_parser
Definition: flac_parser.c:745
if
if(ret)
Definition: filter_design.txt:179
AV_CRC_16_ANSI
@ AV_CRC_16_ANSI
Definition: crc.h:51
score_header
static int score_header(FLACParseContext *fpc, FLACHeaderMarker *header)
Score a header.
Definition: flac_parser.c:413
PTRDIFF_SPECIFIER
#define PTRDIFF_SPECIFIER
Definition: internal.h:192
NULL
#define NULL
Definition: coverity.c:32
FLACFrameInfo::blocksize
FLACCOMMONINFO int blocksize
block size of the frame
Definition: flac.h:86
AVCodecParser::codec_ids
int codec_ids[5]
Definition: avcodec.h:3545
flac_parse
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:514
find_headers_search
static int find_headers_search(FLACParseContext *fpc, uint8_t *buf, int buf_size, int search_start)
Definition: flac_parser.c:204
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:364
AVFifoBuffer::end
uint8_t * end
Definition: fifo.h:33
ff_flac_set_channel_layout
void ff_flac_set_channel_layout(AVCodecContext *avctx)
Definition: flac.c:196
AVCodecParserContext::flags
int flags
Definition: avcodec.h:3410
FLACFrameInfo
Definition: flac.h:84
FLAC_HEADER_CRC_FAIL_PENALTY
#define FLAC_HEADER_CRC_FAIL_PENALTY
Definition: flac_parser.c:52
c
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
FLAC_HEADER_NOT_SCORED_YET
#define FLAC_HEADER_NOT_SCORED_YET
Definition: flac_parser.c:54
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
size
int size
Definition: twinvq_data.h:10344
header
static const uint8_t header[24]
Definition: sdr2.c:67
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
attributes.h
flac_parse_init
static av_cold int flac_parse_init(AVCodecParserContext *c)
Definition: flac_parser.c:715
FLACHeaderMarker::fi
FLACFrameInfo fi
decoded frame header info
Definition: flac_parser.c:66
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1197
FLACParseContext::best_header
FLACHeaderMarker * best_header
highest scoring header within buffer
Definition: flac_parser.c:80
i
int i
Definition: input.c:407
PARSER_FLAG_COMPLETE_FRAMES
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:3411
FLACHeaderMarker::max_score
int max_score
maximum score found after checking each child that has a valid CRC
Definition: flac_parser.c:64
FLACParseContext::end_padded
int end_padded
specifies if fifo_buf's end is padded
Definition: flac_parser.c:88
av_fifo_alloc_array
AVFifoBuffer * av_fifo_alloc_array(size_t nmemb, size_t size)
Initialize an AVFifoBuffer.
Definition: fifo.c:49
uint8_t
uint8_t
Definition: audio_convert.c:194
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
parser.h
len
int len
Definition: vorbis_enc_data.h:452
AVFifoBuffer::buffer
uint8_t * buffer
Definition: fifo.h:32
AVFifoBuffer::wndx
uint32_t wndx
Definition: fifo.h:34
check_header_mismatch
static int check_header_mismatch(FLACParseContext *fpc, FLACHeaderMarker *header, FLACHeaderMarker *child, int log_level_offset)
Definition: flac_parser.c:305
AVCodecParserContext
Definition: avcodec.h:3377
ret
ret
Definition: filter_design.txt:187
FLACParseContext::nb_headers_found
int nb_headers_found
number of headers found in the last flac_parse() call
Definition: flac_parser.c:81
MAX_FRAME_HEADER_SIZE
#define MAX_FRAME_HEADER_SIZE
largest possible size of flac header
Definition: flac_parser.c:57
AVCodecContext
main external API structure.
Definition: avcodec.h:536
av_crc
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
PARSER_FLAG_USE_CODEC_TS
#define PARSER_FLAG_USE_CODEC_TS
Definition: avcodec.h:3415
temp
else temp
Definition: vf_mcdeint.c:259
FLACHeaderMarker::link_penalty
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
FLAC_MIN_HEADERS
#define FLAC_MIN_HEADERS
minimum number of headers buffered and checked before returning frames
Definition: flac_parser.c:45
av_fifo_size
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
FLACHeaderMarker::offset
int offset
byte offset from start of FLACParseContext->buffer
Definition: flac_parser.c:60
av_fifo_freep
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
Definition: fifo.c:63
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
FLAC_HEADER_NOT_PENALIZED_YET
#define FLAC_HEADER_NOT_PENALIZED_YET
Definition: flac_parser.c:53
AVCodecParser
Definition: avcodec.h:3544
FLACParseContext::last_fi
FLACFrameInfo last_fi
last decoded frame header info
Definition: flac_parser.c:91
bytestream.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
flac.h
flac_parse_close
static void flac_parse_close(AVCodecParserContext *c)
Definition: flac_parser.c:730
AV_RB16
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:98