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 "bytestream.h"
38 #include "parser.h"
39 #include "flac_parse.h"
40 
41 /** maximum number of adjacent headers that compare CRCs against each other */
42 #define FLAC_MAX_SEQUENTIAL_HEADERS 4
43 /** minimum number of headers buffered and checked before returning frames */
44 #define FLAC_MIN_HEADERS 10
45 /** estimate for average size of a FLAC frame */
46 #define FLAC_AVG_FRAME_SIZE 8192
47 
48 /** scoring settings for score_header */
49 #define FLAC_HEADER_BASE_SCORE 10
50 #define FLAC_HEADER_CHANGED_PENALTY 7
51 #define FLAC_HEADER_CRC_FAIL_PENALTY 50
52 #define FLAC_HEADER_NOT_PENALIZED_YET 100000
53 #define FLAC_HEADER_NOT_SCORED_YET -100000
54 
55 /** largest possible size of flac header */
56 #define MAX_FRAME_HEADER_SIZE 16
57 #define MAX_FRAME_VERIFY_SIZE (MAX_FRAME_HEADER_SIZE + 1)
58 
59 typedef struct FifoBuffer {
60  uint8_t *buffer;
61  uint8_t *end;
62  uint8_t *rptr;
63  uint8_t *wptr;
64  int empty;
65 } FifoBuffer;
66 
67 typedef struct FLACHeaderMarker {
68  int offset; /**< byte offset from start of FLACParseContext->buffer */
69  int link_penalty[FLAC_MAX_SEQUENTIAL_HEADERS]; /**< array of local scores
70  between this header and the one at a distance equal
71  array position */
72  int max_score; /**< maximum score found after checking each child that
73  has a valid CRC */
74  FLACFrameInfo fi; /**< decoded frame header info */
75  struct FLACHeaderMarker *next; /**< next CRC-8 verified header that
76  immediately follows this one in
77  the bytestream */
78  struct FLACHeaderMarker *best_child; /**< following frame header with
79  which this frame has the best
80  score with */
82 
83 typedef struct FLACParseContext {
84  AVCodecParserContext *pc; /**< parent context */
85  AVCodecContext *avctx; /**< codec context pointer for logging */
86  FLACHeaderMarker *headers; /**< linked-list that starts at the first
87  CRC-8 verified header within buffer */
88  FLACHeaderMarker *best_header; /**< highest scoring header within buffer */
89  int nb_headers_found; /**< number of headers found in the last
90  flac_parse() call */
91  int nb_headers_buffered; /**< number of headers that are buffered */
92  int best_header_valid; /**< flag set when the parser returns junk;
93  if set return best_header next time */
94  FifoBuffer fifo_buf; /**< buffer to store all data until headers
95  can be verified */
96  int end_padded; /**< specifies if fifo_buf's end is padded */
97  uint8_t *wrap_buf; /**< general fifo read buffer when wrapped */
98  int wrap_buf_allocated_size; /**< actual allocated size of the buffer */
99  FLACFrameInfo last_fi; /**< last decoded frame header info */
100  int last_fi_valid; /**< set if last_fi is valid */
102 
103 static int frame_header_is_valid(AVCodecContext *avctx, const uint8_t *buf,
104  FLACFrameInfo *fi)
105 {
106  GetBitContext gb;
107  uint8_t subframe_type;
108 
109  // header plus one byte from first subframe
110  init_get_bits(&gb, buf, MAX_FRAME_VERIFY_SIZE * 8);
111  if (ff_flac_decode_frame_header(avctx, &gb, fi, 127)) {
112  return 0;
113  }
114  // subframe zero bit
115  if (get_bits1(&gb) != 0) {
116  return 0;
117  }
118  // subframe type
119  // 000000 : SUBFRAME_CONSTANT
120  // 000001 : SUBFRAME_VERBATIM
121  // 00001x : reserved
122  // 0001xx : reserved
123  // 001xxx : if(xxx <= 4) SUBFRAME_FIXED, xxx=order ; else reserved
124  // 01xxxx : reserved
125  // 1xxxxx : SUBFRAME_LPC, xxxxx=order-1
126  subframe_type = get_bits(&gb, 6);
127  if (!(subframe_type == 0 ||
128  subframe_type == 1 ||
129  ((subframe_type >= 8) && (subframe_type <= 12)) ||
130  (subframe_type >= 32))) {
131  return 0;
132  }
133 
134  return 1;
135 }
136 
137 static size_t flac_fifo_size(const FifoBuffer *f)
138 {
139  if (f->wptr <= f->rptr && !f->empty)
140  return (f->wptr - f->buffer) + (f->end - f->rptr);
141  return f->wptr - f->rptr;
142 }
143 
144 static size_t flac_fifo_space(const FifoBuffer *f)
145 {
146  return f->end - f->buffer - flac_fifo_size(f);
147 }
148 
149 /**
150  * Non-destructive fast fifo pointer fetching
151  * Returns a pointer from the specified offset.
152  * If possible the pointer points within the fifo buffer.
153  * Otherwise (if it would cause a wrap around,) a pointer to a user-specified
154  * buffer is used.
155  * The pointer can be NULL. In any case it will be reallocated to hold the size.
156  * If the returned pointer will be used after subsequent calls to flac_fifo_read_wrap
157  * then the subsequent calls should pass in a different wrap_buf so as to not
158  * overwrite the contents of the previous wrap_buf.
159  * This function is based on av_fifo_generic_read, which is why there is a comment
160  * about a memory barrier for SMP.
161  */
162 static uint8_t *flac_fifo_read_wrap(FLACParseContext *fpc, int offset, int len,
163  uint8_t **wrap_buf, int *allocated_size)
164 {
165  FifoBuffer *f = &fpc->fifo_buf;
166  uint8_t *start = f->rptr + offset;
167  uint8_t *tmp_buf;
168 
169  if (start >= f->end)
170  start -= f->end - f->buffer;
171  if (f->end - start >= len)
172  return start;
173 
174  tmp_buf = av_fast_realloc(*wrap_buf, allocated_size, len);
175 
176  if (!tmp_buf) {
177  av_log(fpc->avctx, AV_LOG_ERROR,
178  "couldn't reallocate wrap buffer of size %d", len);
179  return NULL;
180  }
181  *wrap_buf = tmp_buf;
182  do {
183  int seg_len = FFMIN(f->end - start, len);
184  memcpy(tmp_buf, start, seg_len);
185  tmp_buf = (uint8_t*)tmp_buf + seg_len;
186 // memory barrier needed for SMP here in theory
187 
188  start += seg_len - (f->end - f->buffer);
189  len -= seg_len;
190  } while (len > 0);
191 
192  return *wrap_buf;
193 }
194 
195 /**
196  * Return a pointer in the fifo buffer where the offset starts at until
197  * the wrap point or end of request.
198  * len will contain the valid length of the returned buffer.
199  * A second call to flac_fifo_read (with new offset and len) should be called
200  * to get the post-wrap buf if the returned len is less than the requested.
201  **/
202 static uint8_t *flac_fifo_read(FifoBuffer *f, int offset, int *len)
203 {
204  uint8_t *start = f->rptr + offset;
205 
206  if (start >= f->end)
207  start -= f->end - f->buffer;
208  *len = FFMIN(*len, f->end - start);
209  return start;
210 }
211 
212 static int flac_fifo_grow(FifoBuffer *f, size_t inc)
213 {
214  size_t size_old = f->end - f->buffer;
215  size_t offset_r = f->rptr - f->buffer;
216  size_t offset_w = f->wptr - f->buffer;
217  size_t size_new;
218 
219  uint8_t *tmp;
220 
221  if (size_old > SIZE_MAX - inc)
222  return AVERROR(EINVAL);
223  size_new = size_old + inc;
224 
225  tmp = av_realloc(f->buffer, size_new);
226  if (!tmp)
227  return AVERROR(ENOMEM);
228 
229  // move the data from the beginning of the ring buffer
230  // to the newly allocated space
231  if (offset_w <= offset_r && !f->empty) {
232  const size_t copy = FFMIN(inc, offset_w);
233  memcpy(tmp + size_old, tmp, copy);
234  if (copy < offset_w) {
235  memmove(tmp, tmp + copy, offset_w - copy);
236  offset_w -= copy;
237  } else
238  offset_w = size_old + copy;
239  }
240 
241  f->buffer = tmp;
242  f->end = f->buffer + size_new;
243  f->rptr = f->buffer + offset_r;
244  f->wptr = f->buffer + offset_w;
245 
246  return 0;
247 }
248 
249 static int flac_fifo_write(FifoBuffer *f, const uint8_t *src, size_t size)
250 {
251  uint8_t *wptr;
252 
253  if (flac_fifo_space(f) < size) {
255  if (ret < 0)
256  return ret;
257  }
258 
259  if (size)
260  f->empty = 0;
261 
262  wptr = f->wptr;
263  do {
264  size_t len = FFMIN(f->end - wptr, size);
265  memcpy(wptr, src, len);
266  src += len;
267  wptr += len;
268  if (wptr >= f->end)
269  wptr = f->buffer;
270  size -= len;
271  } while (size > 0);
272 
273  f->wptr = wptr;
274 
275  return 0;
276 }
277 
278 static void flac_fifo_drain(FifoBuffer *f, size_t size)
279 {
280  size_t size_cur = flac_fifo_size(f);
281 
282  av_assert0(size_cur >= size);
283  if (size_cur == size)
284  f->empty = 1;
285 
286  f->rptr += size;
287  if (f->rptr >= f->end)
288  f->rptr -= f->end - f->buffer;
289 }
290 
291 static int flac_fifo_alloc(FifoBuffer *f, size_t size)
292 {
293  memset(f, 0, sizeof(*f));
294 
295  f->buffer = av_realloc(NULL, size);
296  if (!f->buffer)
297  return AVERROR(ENOMEM);
298 
299  f->wptr = f->buffer;
300  f->rptr = f->buffer;
301  f->end = f->buffer + size;
302 
303  f->empty = 1;
304 
305  return 0;
306 }
307 
309 {
310  av_freep(&f->buffer);
311  memset(f, 0, sizeof(*f));
312 }
313 
315 {
316  FLACFrameInfo fi;
317  uint8_t *header_buf;
318  int size = 0;
319  header_buf = flac_fifo_read_wrap(fpc, offset,
321  &fpc->wrap_buf,
323  if (frame_header_is_valid(fpc->avctx, header_buf, &fi)) {
324  FLACHeaderMarker **end_handle = &fpc->headers;
325  int i;
326 
327  size = 0;
328  while (*end_handle) {
329  end_handle = &(*end_handle)->next;
330  size++;
331  }
332 
333  *end_handle = av_mallocz(sizeof(**end_handle));
334  if (!*end_handle) {
335  av_log(fpc->avctx, AV_LOG_ERROR,
336  "couldn't allocate FLACHeaderMarker\n");
337  return AVERROR(ENOMEM);
338  }
339  (*end_handle)->fi = fi;
340  (*end_handle)->offset = offset;
341 
342  for (i = 0; i < FLAC_MAX_SEQUENTIAL_HEADERS; i++)
343  (*end_handle)->link_penalty[i] = FLAC_HEADER_NOT_PENALIZED_YET;
344 
345  fpc->nb_headers_found++;
346  size++;
347  }
348  return size;
349 }
350 
351 static int find_headers_search(FLACParseContext *fpc, uint8_t *buf,
352  int buf_size, int search_start)
353 {
354  int size = 0, mod_offset = (buf_size - 1) % 4, i, j;
355  uint32_t x;
356 
357  for (i = 0; i < mod_offset; i++) {
358  if ((AV_RB16(buf + i) & 0xFFFE) == 0xFFF8) {
359  int ret = find_headers_search_validate(fpc, search_start + i);
360  size = FFMAX(size, ret);
361  }
362  }
363 
364  for (; i < buf_size - 1; i += 4) {
365  x = AV_RN32(buf + i);
366  if (((x & ~(x + 0x01010101)) & 0x80808080)) {
367  for (j = 0; j < 4; j++) {
368  if ((AV_RB16(buf + i + j) & 0xFFFE) == 0xFFF8) {
369  int ret = find_headers_search_validate(fpc, search_start + i + j);
370  size = FFMAX(size, ret);
371  }
372  }
373  }
374  }
375  return size;
376 }
377 
378 static int find_new_headers(FLACParseContext *fpc, int search_start)
379 {
380  FLACHeaderMarker *end;
381  int search_end, size = 0, read_len, temp;
382  uint8_t *buf;
383  fpc->nb_headers_found = 0;
384 
385  /* Search for a new header of at most 16 bytes. */
386  search_end = flac_fifo_size(&fpc->fifo_buf) - (MAX_FRAME_HEADER_SIZE - 1);
387  read_len = search_end - search_start + 1;
388  buf = flac_fifo_read(&fpc->fifo_buf, search_start, &read_len);
389  size = find_headers_search(fpc, buf, read_len, search_start);
390  search_start += read_len - 1;
391 
392  /* If fifo end was hit do the wrap around. */
393  if (search_start != search_end) {
394  uint8_t wrap[2];
395 
396  wrap[0] = buf[read_len - 1];
397  /* search_start + 1 is the post-wrap offset in the fifo. */
398  read_len = search_end - (search_start + 1) + 1;
399 
400  buf = flac_fifo_read(&fpc->fifo_buf, search_start + 1, &read_len);
401  wrap[1] = buf[0];
402 
403  if ((AV_RB16(wrap) & 0xFFFE) == 0xFFF8) {
404  temp = find_headers_search_validate(fpc, search_start);
405  size = FFMAX(size, temp);
406  }
407  search_start++;
408 
409  /* Continue to do the last half of the wrap. */
410  temp = find_headers_search(fpc, buf, read_len, search_start);
411  size = FFMAX(size, temp);
412  search_start += read_len - 1;
413  }
414 
415  /* Return the size even if no new headers were found. */
416  if (!size && fpc->headers)
417  for (end = fpc->headers; end; end = end->next)
418  size++;
419  return size;
420 }
421 
423  FLACFrameInfo *header_fi,
424  FLACFrameInfo *child_fi,
425  int log_level_offset)
426 {
427  int deduction = 0;
428  if (child_fi->samplerate != header_fi->samplerate) {
429  deduction += FLAC_HEADER_CHANGED_PENALTY;
430  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
431  "sample rate change detected in adjacent frames\n");
432  }
433  if (child_fi->bps != header_fi->bps) {
434  deduction += FLAC_HEADER_CHANGED_PENALTY;
435  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
436  "bits per sample change detected in adjacent frames\n");
437  }
438  if (child_fi->is_var_size != header_fi->is_var_size) {
439  /* Changing blocking strategy not allowed per the spec */
440  deduction += FLAC_HEADER_BASE_SCORE;
441  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
442  "blocking strategy change detected in adjacent frames\n");
443  }
444  if (child_fi->channels != header_fi->channels) {
445  deduction += FLAC_HEADER_CHANGED_PENALTY;
446  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
447  "number of channels change detected in adjacent frames\n");
448  }
449  return deduction;
450 }
451 
454  FLACHeaderMarker *child,
455  int log_level_offset)
456 {
457  FLACFrameInfo *header_fi = &header->fi, *child_fi = &child->fi;
458  int check_crc, deduction, deduction_expected = 0, i;
459  deduction = check_header_fi_mismatch(fpc, header_fi, child_fi,
460  log_level_offset);
461  /* Check sample and frame numbers. */
462  if ((child_fi->frame_or_sample_num - header_fi->frame_or_sample_num
463  != header_fi->blocksize) &&
464  (child_fi->frame_or_sample_num
465  != header_fi->frame_or_sample_num + 1)) {
466  FLACHeaderMarker *curr;
467  int64_t expected_frame_num, expected_sample_num;
468  /* If there are frames in the middle we expect this deduction,
469  as they are probably valid and this one follows it */
470 
471  expected_frame_num = expected_sample_num = header_fi->frame_or_sample_num;
472  curr = header;
473  while (curr != child) {
474  /* Ignore frames that failed all crc checks */
475  for (i = 0; i < FLAC_MAX_SEQUENTIAL_HEADERS; i++) {
477  expected_frame_num++;
478  expected_sample_num += curr->fi.blocksize;
479  break;
480  }
481  }
482  curr = curr->next;
483  }
484 
485  if (expected_frame_num == child_fi->frame_or_sample_num ||
486  expected_sample_num == child_fi->frame_or_sample_num)
487  deduction_expected = deduction ? 0 : 1;
488 
489  deduction += FLAC_HEADER_CHANGED_PENALTY;
490  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
491  "sample/frame number mismatch in adjacent frames\n");
492  }
493 
494  if (fpc->last_fi.is_var_size == header_fi->is_var_size) {
495  if (fpc->last_fi.is_var_size &&
497  check_crc = 0;
498  } else if (!fpc->last_fi.is_var_size &&
499  fpc->last_fi.frame_or_sample_num + 1 == header_fi->frame_or_sample_num) {
500  check_crc = 0;
501  } else {
502  check_crc = !deduction && !deduction_expected;
503  }
504  } else {
505  check_crc = !deduction && !deduction_expected;
506  }
507 
508  /* If we have suspicious headers, check the CRC between them */
509  if (check_crc || (deduction && !deduction_expected)) {
510  FLACHeaderMarker *curr;
511  int read_len;
512  uint8_t *buf;
513  uint32_t crc = 1;
514  int inverted_test = 0;
515 
516  /* Since CRC is expensive only do it if we haven't yet.
517  This assumes a CRC penalty is greater than all other check penalties */
518  curr = header->next;
519  for (i = 0; i < FLAC_MAX_SEQUENTIAL_HEADERS && curr != child; i++)
520  curr = curr->next;
521 
522  if (header->link_penalty[i] < FLAC_HEADER_CRC_FAIL_PENALTY ||
523  header->link_penalty[i] == FLAC_HEADER_NOT_PENALIZED_YET) {
524  FLACHeaderMarker *start, *end;
525 
526  /* Although overlapping chains are scored, the crc should never
527  have to be computed twice for a single byte. */
528  start = header;
529  end = child;
530  if (i > 0 &&
531  header->link_penalty[i - 1] >= FLAC_HEADER_CRC_FAIL_PENALTY) {
532  while (start->next != child)
533  start = start->next;
534  inverted_test = 1;
535  } else if (i > 0 &&
536  header->next->link_penalty[i-1] >=
538  end = header->next;
539  inverted_test = 1;
540  }
541 
542  read_len = end->offset - start->offset;
543  buf = flac_fifo_read(&fpc->fifo_buf, start->offset, &read_len);
544  crc = av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf, read_len);
545  read_len = (end->offset - start->offset) - read_len;
546 
547  if (read_len) {
548  buf = flac_fifo_read(&fpc->fifo_buf, end->offset - read_len, &read_len);
549  crc = av_crc(av_crc_get_table(AV_CRC_16_ANSI), crc, buf, read_len);
550  }
551  }
552 
553  if (!crc ^ !inverted_test) {
554  deduction += FLAC_HEADER_CRC_FAIL_PENALTY;
555  av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,
556  "crc check failed from offset %i (frame %"PRId64") to %i (frame %"PRId64")\n",
557  header->offset, header_fi->frame_or_sample_num,
558  child->offset, child_fi->frame_or_sample_num);
559  }
560  }
561  return deduction;
562 }
563 
564 /**
565  * Score a header.
566  *
567  * Give FLAC_HEADER_BASE_SCORE points to a frame for existing.
568  * If it has children, (subsequent frames of which the preceding CRC footer
569  * validates against this one,) then take the maximum score of the children,
570  * with a penalty of FLAC_HEADER_CHANGED_PENALTY applied for each change to
571  * bps, sample rate, channels, but not decorrelation mode, or blocksize,
572  * because it can change often.
573  **/
575 {
576  FLACHeaderMarker *child;
577  int dist = 0;
578  int child_score;
579  int base_score = FLAC_HEADER_BASE_SCORE;
580  if (header->max_score != FLAC_HEADER_NOT_SCORED_YET)
581  return header->max_score;
582 
583  /* Modify the base score with changes from the last output header */
584  if (fpc->last_fi_valid) {
585  /* Silence the log since this will be repeated if selected */
586  base_score -= check_header_fi_mismatch(fpc, &fpc->last_fi, &header->fi,
587  AV_LOG_DEBUG);
588  }
589 
590  header->max_score = base_score;
591 
592  /* Check and compute the children's scores. */
593  child = header->next;
594  for (dist = 0; dist < FLAC_MAX_SEQUENTIAL_HEADERS && child; dist++) {
595  /* Look at the child's frame header info and penalize suspicious
596  changes between the headers. */
597  if (header->link_penalty[dist] == FLAC_HEADER_NOT_PENALIZED_YET) {
598  header->link_penalty[dist] = check_header_mismatch(fpc, header,
599  child, AV_LOG_DEBUG);
600  }
601  child_score = score_header(fpc, child) - header->link_penalty[dist];
602 
603  if (FLAC_HEADER_BASE_SCORE + child_score > header->max_score) {
604  /* Keep the child because the frame scoring is dynamic. */
605  header->best_child = child;
606  header->max_score = base_score + child_score;
607  }
608  child = child->next;
609  }
610 
611  return header->max_score;
612 }
613 
615 {
616  FLACHeaderMarker *curr;
617  int best_score = FLAC_HEADER_NOT_SCORED_YET;
618  /* First pass to clear all old scores. */
619  for (curr = fpc->headers; curr; curr = curr->next)
621 
622  /* Do a second pass to score them all. */
623  for (curr = fpc->headers; curr; curr = curr->next) {
624  if (score_header(fpc, curr) > best_score) {
625  fpc->best_header = curr;
626  best_score = curr->max_score;
627  }
628  }
629 }
630 
631 static int get_best_header(FLACParseContext *fpc, const uint8_t **poutbuf,
632  int *poutbuf_size)
633 {
635  FLACHeaderMarker *child = header->best_child;
636  if (!child) {
637  *poutbuf_size = flac_fifo_size(&fpc->fifo_buf) - header->offset;
638  } else {
639  *poutbuf_size = child->offset - header->offset;
640 
641  /* If the child has suspicious changes, log them */
642  check_header_mismatch(fpc, header, child, 0);
643  }
644 
645  ff_flac_set_channel_layout(fpc->avctx, header->fi.channels);
646 
647  fpc->avctx->sample_rate = header->fi.samplerate;
648  fpc->pc->duration = header->fi.blocksize;
649  *poutbuf = flac_fifo_read_wrap(fpc, header->offset, *poutbuf_size,
650  &fpc->wrap_buf,
652 
653  if (fpc->pc->flags & PARSER_FLAG_USE_CODEC_TS) {
654  if (header->fi.is_var_size)
655  fpc->pc->pts = header->fi.frame_or_sample_num;
656  else if (header->best_child)
657  fpc->pc->pts = header->fi.frame_or_sample_num * header->fi.blocksize;
658  }
659 
660  fpc->best_header_valid = 0;
661  fpc->last_fi_valid = 1;
662  fpc->last_fi = header->fi;
663 
664  /* Return the negative overread index so the client can compute pos.
665  This should be the amount overread to the beginning of the child */
666  if (child) {
667  int64_t offset = child->offset - flac_fifo_size(&fpc->fifo_buf);
668  if (offset > -(1 << 28))
669  return offset;
670  }
671  return 0;
672 }
673 
675  const uint8_t **poutbuf, int *poutbuf_size,
676  const uint8_t *buf, int buf_size)
677 {
678  FLACParseContext *fpc = s->priv_data;
679  FLACHeaderMarker *curr;
680  int nb_headers;
681  const uint8_t *read_end = buf;
682  const uint8_t *read_start = buf;
683 
684  if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
685  FLACFrameInfo fi;
686  if (frame_header_is_valid(avctx, buf, &fi)) {
687  s->duration = fi.blocksize;
688  if (!avctx->sample_rate)
689  avctx->sample_rate = fi.samplerate;
690  if (fpc->pc->flags & PARSER_FLAG_USE_CODEC_TS) {
691  fpc->pc->pts = fi.frame_or_sample_num;
692  if (!fi.is_var_size)
693  fpc->pc->pts *= fi.blocksize;
694  }
695  }
696  *poutbuf = buf;
697  *poutbuf_size = buf_size;
698  return buf_size;
699  }
700 
701  fpc->avctx = avctx;
703  return get_best_header(fpc, poutbuf, poutbuf_size);
704 
705  /* If a best_header was found last call remove it with the buffer data. */
706  if (fpc->best_header && fpc->best_header->best_child) {
708  FLACHeaderMarker *best_child = fpc->best_header->best_child;
709 
710  /* Remove headers in list until the end of the best_header. */
711  for (curr = fpc->headers; curr != best_child; curr = temp) {
712  if (curr != fpc->best_header) {
713  av_log(avctx, AV_LOG_DEBUG,
714  "dropping low score %i frame header from offset %i to %i\n",
715  curr->max_score, curr->offset, curr->next->offset);
716  }
717  temp = curr->next;
718  av_free(curr);
719  fpc->nb_headers_buffered--;
720  }
721  /* Release returned data from ring buffer. */
722  flac_fifo_drain(&fpc->fifo_buf, best_child->offset);
723 
724  /* Fix the offset for the headers remaining to match the new buffer. */
725  for (curr = best_child->next; curr; curr = curr->next)
726  curr->offset -= best_child->offset;
727 
728  best_child->offset = 0;
729  fpc->headers = best_child;
731  fpc->best_header = best_child;
732  return get_best_header(fpc, poutbuf, poutbuf_size);
733  }
734  fpc->best_header = NULL;
735  } else if (fpc->best_header) {
736  /* No end frame no need to delete the buffer; probably eof */
738 
739  for (curr = fpc->headers; curr != fpc->best_header; curr = temp) {
740  temp = curr->next;
741  av_free(curr);
742  fpc->nb_headers_buffered--;
743  }
744  fpc->headers = fpc->best_header->next;
745  av_freep(&fpc->best_header);
746  fpc->nb_headers_buffered--;
747  }
748 
749  /* Find and score new headers. */
750  /* buf_size is zero when flushing, so check for this since we do */
751  /* not want to try to read more input once we have found the end. */
752  /* Also note that buf can't be NULL. */
753  while ((buf_size && read_end < buf + buf_size &&
755  || (!buf_size && !fpc->end_padded)) {
756  int start_offset, ret;
757 
758  /* Pad the end once if EOF, to check the final region for headers. */
759  if (!buf_size) {
760  fpc->end_padded = 1;
761  read_end = read_start + MAX_FRAME_HEADER_SIZE;
762  } else {
763  /* The maximum read size is the upper-bound of what the parser
764  needs to have the required number of frames buffered */
765  int nb_desired = FLAC_MIN_HEADERS - fpc->nb_headers_buffered + 1;
766  read_end = read_end + FFMIN(buf + buf_size - read_end,
767  nb_desired * FLAC_AVG_FRAME_SIZE);
768  }
769 
770  if (!flac_fifo_space(&fpc->fifo_buf) &&
772  fpc->nb_headers_buffered * 20) {
773  /* There is less than one valid flac header buffered for 20 headers
774  * buffered. Therefore the fifo is most likely filled with invalid
775  * data and the input is not a flac file. */
776  goto handle_error;
777  }
778 
779  /* Fill the buffer. */
780  if (buf_size) {
781  ret = flac_fifo_write(&fpc->fifo_buf, read_start,
782  read_end - read_start);
783  } else {
784  int8_t pad[MAX_FRAME_HEADER_SIZE] = { 0 };
785  ret = flac_fifo_write(&fpc->fifo_buf, pad, sizeof(pad));
786  }
787  if (ret < 0) {
788  av_log(avctx, AV_LOG_ERROR, "Error buffering data\n");
789  goto handle_error;
790  }
791 
792  /* Tag headers and update sequences. */
793  start_offset = flac_fifo_size(&fpc->fifo_buf) -
794  ((read_end - read_start) + (MAX_FRAME_HEADER_SIZE - 1));
795  start_offset = FFMAX(0, start_offset);
796  nb_headers = find_new_headers(fpc, start_offset);
797 
798  if (nb_headers < 0) {
799  av_log(avctx, AV_LOG_ERROR,
800  "find_new_headers couldn't allocate FLAC header\n");
801  goto handle_error;
802  }
803 
804  fpc->nb_headers_buffered = nb_headers;
805  /* Wait till FLAC_MIN_HEADERS to output a valid frame. */
806  if (!fpc->end_padded && fpc->nb_headers_buffered < FLAC_MIN_HEADERS) {
807  if (read_end < buf + buf_size) {
808  read_start = read_end;
809  continue;
810  } else {
811  goto handle_error;
812  }
813  }
814 
815  /* If headers found, update the scores since we have longer chains. */
816  if (fpc->end_padded || fpc->nb_headers_found)
817  score_sequences(fpc);
818 
819  /* restore the state pre-padding */
820  if (fpc->end_padded) {
821  int empty = flac_fifo_size(&fpc->fifo_buf) == MAX_FRAME_HEADER_SIZE;
822  int warp = fpc->fifo_buf.wptr - fpc->fifo_buf.buffer < MAX_FRAME_HEADER_SIZE;
823  /* HACK: drain the tail of the fifo */
825  if (warp) {
826  fpc->fifo_buf.wptr += fpc->fifo_buf.end -
827  fpc->fifo_buf.buffer;
828  }
829  fpc->fifo_buf.empty = empty;
830  read_start = read_end = NULL;
831  }
832  }
833 
834  for (curr = fpc->headers; curr; curr = curr->next) {
835  if (!fpc->best_header || curr->max_score > fpc->best_header->max_score) {
836  fpc->best_header = curr;
837  }
838  }
839 
840  if (fpc->best_header && fpc->best_header->max_score <= 0) {
841  // Only accept a bad header if there is no other option to continue
842  if (!buf_size || read_end != buf || fpc->nb_headers_buffered < FLAC_MIN_HEADERS)
843  fpc->best_header = NULL;
844  }
845 
846  if (fpc->best_header) {
847  fpc->best_header_valid = 1;
848  if (fpc->best_header->offset > 0) {
849  /* Output a junk frame. */
850  av_log(avctx, AV_LOG_DEBUG, "Junk frame till offset %i\n",
851  fpc->best_header->offset);
852 
853  /* Set duration to 0. It is unknown or invalid in a junk frame. */
854  s->duration = 0;
855  *poutbuf_size = fpc->best_header->offset;
856  *poutbuf = flac_fifo_read_wrap(fpc, 0, *poutbuf_size,
857  &fpc->wrap_buf,
859  return buf_size ? (read_end - buf) : (fpc->best_header->offset -
860  flac_fifo_size(&fpc->fifo_buf));
861  }
862  if (!buf_size)
863  return get_best_header(fpc, poutbuf, poutbuf_size);
864  }
865 
866 handle_error:
867  *poutbuf = NULL;
868  *poutbuf_size = 0;
869  return buf_size ? read_end - buf : 0;
870 }
871 
873 {
874  FLACParseContext *fpc = c->priv_data;
875  int ret;
876 
877  fpc->pc = c;
878  /* There will generally be FLAC_MIN_HEADERS buffered in the fifo before
879  it drains. This is allocated early to avoid slow reallocation. */
881  if (ret < 0) {
882  av_log(fpc->avctx, AV_LOG_ERROR,
883  "couldn't allocate fifo_buf\n");
884  return AVERROR(ENOMEM);
885  }
886  return 0;
887 }
888 
890 {
891  FLACParseContext *fpc = c->priv_data;
892  FLACHeaderMarker *curr = fpc->headers, *temp;
893 
894  while (curr) {
895  temp = curr->next;
896  av_free(curr);
897  curr = temp;
898  }
899  fpc->headers = NULL;
900  flac_fifo_free(&fpc->fifo_buf);
901  av_freep(&fpc->wrap_buf);
902 }
903 
906  .priv_data_size = sizeof(FLACParseContext),
907  .parser_init = flac_parse_init,
908  .parser_parse = flac_parse,
909  .parser_close = flac_parse_close,
910 };
FLACParseContext
Definition: flac_parser.c:83
FLACParseContext::headers
FLACHeaderMarker * headers
linked-list that starts at the first CRC-8 verified header within buffer
Definition: flac_parser.c:86
FLAC_HEADER_BASE_SCORE
#define FLAC_HEADER_BASE_SCORE
scoring settings for score_header
Definition: flac_parser.c:49
frame_header_is_valid
static int frame_header_is_valid(AVCodecContext *avctx, const uint8_t *buf, FLACFrameInfo *fi)
Definition: flac_parser.c:103
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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:422
FLACParseContext::nb_headers_buffered
int nb_headers_buffered
number of headers that are buffered
Definition: flac_parser.c:91
AVCodecParserContext::pts
int64_t pts
Definition: avcodec.h:2819
find_new_headers
static int find_new_headers(FLACParseContext *fpc, int search_start)
Definition: flac_parser.c:378
FLACHeaderMarker
Definition: flac_parser.c:67
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::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1007
flac_fifo_free
static void flac_fifo_free(FifoBuffer *f)
Definition: flac_parser.c:308
AVCodecParserContext::duration
int duration
Duration of the current frame.
Definition: avcodec.h:2914
FLACParseContext::wrap_buf
uint8_t * wrap_buf
general fifo read buffer when wrapped
Definition: flac_parser.c:97
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
FLACHeaderMarker::best_child
struct FLACHeaderMarker * best_child
following frame header with which this frame has the best score with
Definition: flac_parser.c:78
FifoBuffer::buffer
uint8_t * buffer
Definition: flac_parser.c:60
FLACFrameInfo::frame_or_sample_num
int64_t frame_or_sample_num
frame number or sample number
Definition: flac_parse.h:48
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_parse.h:49
score_sequences
static void score_sequences(FLACParseContext *fpc)
Definition: flac_parser.c:614
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:51
FifoBuffer::end
uint8_t * end
Definition: flac_parser.c:61
AV_CODEC_ID_FLAC
@ AV_CODEC_ID_FLAC
Definition: codec_id.h:447
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
FLAC_HEADER_CHANGED_PENALTY
#define FLAC_HEADER_CHANGED_PENALTY
Definition: flac_parser.c:50
FLAC_MAX_SEQUENTIAL_HEADERS
#define FLAC_MAX_SEQUENTIAL_HEADERS
maximum number of adjacent headers that compare CRCs against each other
Definition: flac_parser.c:42
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:649
FLACParseContext::wrap_buf_allocated_size
int wrap_buf_allocated_size
actual allocated size of the buffer
Definition: flac_parser.c:98
crc.h
flac_parse.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:162
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
ff_flac_parser
const AVCodecParser ff_flac_parser
Definition: flac_parser.c:904
ff_flac_set_channel_layout
void ff_flac_set_channel_layout(AVCodecContext *avctx, int channels)
Definition: flac.c:173
wrap
#define wrap(func)
Definition: neontest.h:65
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:92
get_best_header
static int get_best_header(FLACParseContext *fpc, const uint8_t **poutbuf, int *poutbuf_size)
Definition: flac_parser.c:631
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FLACParseContext::fifo_buf
FifoBuffer fifo_buf
buffer to store all data until headers can be verified
Definition: flac_parser.c:94
av_cold
#define av_cold
Definition: attributes.h:90
FLACFrameInfo::channels
int channels
number of channels
Definition: flac_parse.h:44
FLACHeaderMarker::next
struct FLACHeaderMarker * next
next CRC-8 verified header that immediately follows this one in the bytestream
Definition: flac_parser.c:75
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:505
FifoBuffer::wptr
uint8_t * wptr
Definition: flac_parser.c:63
FLAC_AVG_FRAME_SIZE
#define FLAC_AVG_FRAME_SIZE
estimate for average size of a FLAC frame
Definition: flac_parser.c:46
s
#define s(width, name)
Definition: cbs_vp9.c:256
FLACFrameInfo::blocksize
int blocksize
block size of the frame
Definition: flac_parse.h:46
flac_fifo_alloc
static int flac_fifo_alloc(FifoBuffer *f, size_t size)
Definition: flac_parser.c:291
flac_fifo_read
static uint8_t * flac_fifo_read(FifoBuffer *f, 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:202
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
FLACParseContext::last_fi_valid
int last_fi_valid
set if last_fi is valid
Definition: flac_parser.c:100
FLACParseContext::avctx
AVCodecContext * avctx
codec context pointer for logging
Definition: flac_parser.c:85
find_headers_search_validate
static int find_headers_search_validate(FLACParseContext *fpc, int offset)
Definition: flac_parser.c:314
FLACParseContext::pc
AVCodecParserContext * pc
parent context
Definition: flac_parser.c:84
if
if(ret)
Definition: filter_design.txt:179
AV_CRC_16_ANSI
@ AV_CRC_16_ANSI
Definition: crc.h:50
score_header
static int score_header(FLACParseContext *fpc, FLACHeaderMarker *header)
Score a header.
Definition: flac_parser.c:574
flac_fifo_drain
static void flac_fifo_drain(FifoBuffer *f, size_t size)
Definition: flac_parser.c:278
NULL
#define NULL
Definition: coverity.c:32
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:153
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:674
find_headers_search
static int find_headers_search(FLACParseContext *fpc, uint8_t *buf, int buf_size, int search_start)
Definition: flac_parser.c:351
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:364
AVCodecParserContext::flags
int flags
Definition: avcodec.h:2833
FLACFrameInfo
Definition: flac_parse.h:42
FLAC_HEADER_CRC_FAIL_PENALTY
#define FLAC_HEADER_CRC_FAIL_PENALTY
Definition: flac_parser.c:51
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:53
f
f
Definition: af_crystalizer.c:122
flac_fifo_write
static int flac_fifo_write(FifoBuffer *f, const uint8_t *src, size_t size)
Definition: flac_parser.c:249
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:187
AVCodecParser::codec_ids
int codec_ids[7]
Definition: avcodec.h:2960
size
int size
Definition: twinvq_data.h:10344
flac_fifo_grow
static int flac_fifo_grow(FifoBuffer *f, size_t inc)
Definition: flac_parser.c:212
header
static const uint8_t header[24]
Definition: sdr2.c:67
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:872
FLACHeaderMarker::fi
FLACFrameInfo fi
decoded frame header info
Definition: flac_parser.c:74
FLACParseContext::best_header
FLACHeaderMarker * best_header
highest scoring header within buffer
Definition: flac_parser.c:88
flac_fifo_space
static size_t flac_fifo_space(const FifoBuffer *f)
Definition: flac_parser.c:144
PARSER_FLAG_COMPLETE_FRAMES
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:2834
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
FLACHeaderMarker::max_score
int max_score
maximum score found after checking each child that has a valid CRC
Definition: flac_parser.c:72
FifoBuffer::rptr
uint8_t * rptr
Definition: flac_parser.c:62
FLACParseContext::end_padded
int end_padded
specifies if fifo_buf's end is padded
Definition: flac_parser.c:96
FifoBuffer
Definition: flac_parser.c:59
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
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:264
MAX_FRAME_VERIFY_SIZE
#define MAX_FRAME_VERIFY_SIZE
Definition: flac_parser.c:57
parser.h
len
int len
Definition: vorbis_enc_data.h:426
flac_fifo_size
static size_t flac_fifo_size(const FifoBuffer *f)
Definition: flac_parser.c:137
check_header_mismatch
static int check_header_mismatch(FLACParseContext *fpc, FLACHeaderMarker *header, FLACHeaderMarker *child, int log_level_offset)
Definition: flac_parser.c:452
FLACFrameInfo::samplerate
int samplerate
sample rate
Definition: flac_parse.h:43
AVCodecParserContext
Definition: avcodec.h:2800
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:89
MAX_FRAME_HEADER_SIZE
#define MAX_FRAME_HEADER_SIZE
largest possible size of flac header
Definition: flac_parser.c:56
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AVCodecContext
main external API structure.
Definition: avcodec.h:398
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:2838
temp
else temp
Definition: vf_mcdeint.c:248
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:69
FLAC_MIN_HEADERS
#define FLAC_MIN_HEADERS
minimum number of headers buffered and checked before returning frames
Definition: flac_parser.c:44
FLACHeaderMarker::offset
int offset
byte offset from start of FLACParseContext->buffer
Definition: flac_parser.c:68
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FifoBuffer::empty
int empty
Definition: flac_parser.c:64
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
FLAC_HEADER_NOT_PENALIZED_YET
#define FLAC_HEADER_NOT_PENALIZED_YET
Definition: flac_parser.c:52
AVCodecParser
Definition: avcodec.h:2959
FLACParseContext::last_fi
FLACFrameInfo last_fi
last decoded frame header info
Definition: flac_parser.c:99
bytestream.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
FLACFrameInfo::bps
int bps
bits-per-sample
Definition: flac_parse.h:45
flac_parse_close
static void flac_parse_close(AVCodecParserContext *c)
Definition: flac_parser.c:889
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