FFmpeg: libavcodec/flac_parser.c Source File

FFmpeg

[フレーム]

libavcodec

flac_parser.c

Go to the documentation of this file.

1 /*

2 * FLAC parser

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 */

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 **/

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"

42 /** maximum number of adjacent headers that compare CRCs against each other */

43 #define FLAC_MAX_SEQUENTIAL_HEADERS 3

44 /** minimum number of headers buffered and checked before returning frames */

45 #define FLAC_MIN_HEADERS 10

46 /** estimate for average size of a FLAC frame */

47 #define FLAC_AVG_FRAME_SIZE 8192

49 /** scoring settings for score_header */

50 #define FLAC_HEADER_BASE_SCORE 10

51 #define FLAC_HEADER_CHANGED_PENALTY 7

52 #define FLAC_HEADER_CRC_FAIL_PENALTY 50

53 #define FLAC_HEADER_NOT_PENALIZED_YET 100000

54 #define FLAC_HEADER_NOT_SCORED_YET -100000

56 /** largest possible size of flac header */

57 #define MAX_FRAME_HEADER_SIZE 16

59 typedef struct FLACHeaderMarker {

60 int offset; /**< byte offset from start of FLACParseContext->buffer */

61 int *link_penalty; /**< pointer to array of local scores between this header

62 and the one at a distance equal array position */

63 int max_score; /**< maximum score found after checking each child that

64 has a valid CRC */

65 FLACFrameInfo fi; /**< decoded frame header info */

66 struct FLACHeaderMarker *next; /**< next CRC-8 verified header that

67 immediately follows this one in

68 the bytestream */

69 struct FLACHeaderMarker *best_child; /**< following frame header with

70 which this frame has the best

71 score with */

72 } FLACHeaderMarker;

74 typedef struct FLACParseContext {

75 AVCodecParserContext *pc; /**< parent context */

76 AVCodecContext *avctx; /**< codec context pointer for logging */

77 FLACHeaderMarker *headers; /**< linked-list that starts at the first

78 CRC-8 verified header within buffer */

79 FLACHeaderMarker *best_header; /**< highest scoring header within buffer */

80 int nb_headers_found; /**< number of headers found in the last

81 flac_parse() call */

82 int nb_headers_buffered; /**< number of headers that are buffered */

83 int best_header_valid; /**< flag set when the parser returns junk;

84 if set return best_header next time */

85 AVFifoBuffer *fifo_buf; /**< buffer to store all data until headers

86 can be verified */

87 int end_padded; /**< specifies if fifo_buf's end is padded */

88 uint8_t *wrap_buf; /**< general fifo read buffer when wrapped */

89 int wrap_buf_allocated_size; /**< actual allocated size of the buffer */

90 FLACFrameInfo last_fi; /**< last decoded frame header info */

91 int last_fi_valid; /**< set if last_fi is valid */

92 } FLACParseContext;

94 static int frame_header_is_valid(AVCodecContext *avctx, const uint8_t *buf,

95 FLACFrameInfo *fi)

96 {

97 GetBitContext gb;

98 init_get_bits(&gb, buf, MAX_FRAME_HEADER_SIZE * 8);

99 return !ff_flac_decode_frame_header(avctx, &gb, fi, 127);

100 }

101

102 /**

103 * Non-destructive fast fifo pointer fetching

104 * Returns a pointer from the specified offset.

105 * If possible the pointer points within the fifo buffer.

106 * Otherwise (if it would cause a wrap around,) a pointer to a user-specified

107 * buffer is used.

108 * The pointer can be NULL. In any case it will be reallocated to hold the size.

109 * If the returned pointer will be used after subsequent calls to flac_fifo_read_wrap

110 * then the subsequent calls should pass in a different wrap_buf so as to not

111 * overwrite the contents of the previous wrap_buf.

112 * This function is based on av_fifo_generic_read, which is why there is a comment

113 * about a memory barrier for SMP.

114 */

115 static uint8_t* flac_fifo_read_wrap(FLACParseContext *fpc, int offset, int len,

116 uint8_t** wrap_buf, int* allocated_size)

117 {

118 AVFifoBuffer *f = fpc->fifo_buf;

119 uint8_t *start = f->rptr + offset;

120 uint8_t *tmp_buf;

121

122 if (start >= f->end)

123 start -= f->end - f->buffer;

124 if (f->end - start >= len)

125 return start;

126

127 tmp_buf = av_fast_realloc(*wrap_buf, allocated_size, len);

128

129 if (!tmp_buf) {

130 av_log(fpc->avctx, AV_LOG_ERROR,

131 "couldn't reallocate wrap buffer of size %d", len);

132 return NULL;

133 }

134 *wrap_buf = tmp_buf;

135 do {

136 int seg_len = FFMIN(f->end - start, len);

137 memcpy(tmp_buf, start, seg_len);

138 tmp_buf = (uint8_t*)tmp_buf + seg_len;

139 // memory barrier needed for SMP here in theory

140

141 start += seg_len - (f->end - f->buffer);

142 len -= seg_len;

143 } while (len > 0);

144

145 return *wrap_buf;

146 }

147

148 /**

149 * Return a pointer in the fifo buffer where the offset starts at until

150 * the wrap point or end of request.

151 * len will contain the valid length of the returned buffer.

152 * A second call to flac_fifo_read (with new offset and len) should be called

153 * to get the post-wrap buf if the returned len is less than the requested.

154 **/

155 static uint8_t* flac_fifo_read(FLACParseContext *fpc, int offset, int *len)

156 {

157 AVFifoBuffer *f = fpc->fifo_buf;

158 uint8_t *start = f->rptr + offset;

159

160 if (start >= f->end)

161 start -= f->end - f->buffer;

162 *len = FFMIN(*len, f->end - start);

163 return start;

164 }

165

166 static int find_headers_search_validate(FLACParseContext *fpc, int offset)

167 {

168 FLACFrameInfo fi;

169 uint8_t *header_buf;

170 int size = 0;

171 header_buf = flac_fifo_read_wrap(fpc, offset,

172 MAX_FRAME_HEADER_SIZE,

173 &fpc->wrap_buf,

174 &fpc->wrap_buf_allocated_size);

175 if (frame_header_is_valid(fpc->avctx, header_buf, &fi)) {

176 FLACHeaderMarker **end_handle = &fpc->headers;

177 int i;

178

179 size = 0;

180 while (*end_handle) {

181 end_handle = &(*end_handle)->next;

182 size++;

183 }

184

185 *end_handle = av_mallocz(sizeof(FLACHeaderMarker));

186 if (!*end_handle) {

187 av_log(fpc->avctx, AV_LOG_ERROR,

188 "couldn't allocate FLACHeaderMarker\n");

189 return AVERROR(ENOMEM);

190 }

191 (*end_handle)->fi = fi;

192 (*end_handle)->offset = offset;

193 (*end_handle)->link_penalty = av_malloc(sizeof(int) *

194 FLAC_MAX_SEQUENTIAL_HEADERS);

195 for (i = 0; i < FLAC_MAX_SEQUENTIAL_HEADERS; i++)

196 (*end_handle)->link_penalty[i] = FLAC_HEADER_NOT_PENALIZED_YET;

197

198 fpc->nb_headers_found++;

199 size++;

200 }

201 return size;

202 }

203

204 static int find_headers_search(FLACParseContext *fpc, uint8_t *buf, int buf_size,

205 int search_start)

206

207 {

208 int size = 0, mod_offset = (buf_size - 1) % 4, i, j;

209 uint32_t x;

210

211 for (i = 0; i < mod_offset; i++) {

212 if ((AV_RB16(buf + i) & 0xFFFE) == 0xFFF8)

213 size = find_headers_search_validate(fpc, search_start + i);

214 }

215

216 for (; i < buf_size - 1; i += 4) {

217 x = AV_RB32(buf + i);

218 if (((x & ~(x + 0x01010101)) & 0x80808080)) {

219 for (j = 0; j < 4; j++) {

220 if ((AV_RB16(buf + i + j) & 0xFFFE) == 0xFFF8)

221 size = find_headers_search_validate(fpc, search_start + i + j);

222 }

223 }

224 }

225 return size;

226 }

227

228 static int find_new_headers(FLACParseContext *fpc, int search_start)

229 {

230 FLACHeaderMarker *end;

231 int search_end, size = 0, read_len, temp;

232 uint8_t *buf;

233 fpc->nb_headers_found = 0;

234

235 /* Search for a new header of at most 16 bytes. */

236 search_end = av_fifo_size(fpc->fifo_buf) - (MAX_FRAME_HEADER_SIZE - 1);

237 read_len = search_end - search_start + 1;

238 buf = flac_fifo_read(fpc, search_start, &read_len);

239 size = find_headers_search(fpc, buf, read_len, search_start);

240 search_start += read_len - 1;

241

242 /* If fifo end was hit do the wrap around. */

243 if (search_start != search_end) {

244 uint8_t wrap[2];

245

246 wrap[0] = buf[read_len - 1];

247 read_len = search_end - search_start + 1;

248

249 /* search_start + 1 is the post-wrap offset in the fifo. */

250 buf = flac_fifo_read(fpc, search_start + 1, &read_len);

251 wrap[1] = buf[0];

252

253 if ((AV_RB16(wrap) & 0xFFFE) == 0xFFF8) {

254 temp = find_headers_search_validate(fpc, search_start);

255 size = FFMAX(size, temp);

256 }

257 search_start++;

258

259 /* Continue to do the last half of the wrap. */

260 temp = find_headers_search(fpc, buf, read_len, search_start);

261 size = FFMAX(size, temp);

262 search_start += read_len - 1;

263 }

264

265 /* Return the size even if no new headers were found. */

266 if (!size && fpc->headers)

267 for (end = fpc->headers; end; end = end->next)

268 size++;

269 return size;

270 }

271

272 static int check_header_fi_mismatch(FLACParseContext *fpc,

273 FLACFrameInfo *header_fi,

274 FLACFrameInfo *child_fi,

275 int log_level_offset)

276 {

277 int deduction = 0;

278 if (child_fi->samplerate != header_fi->samplerate) {

279 deduction += FLAC_HEADER_CHANGED_PENALTY;

280 av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,

281 "sample rate change detected in adjacent frames\n");

282 }

283 if (child_fi->bps != header_fi->bps) {

284 deduction += FLAC_HEADER_CHANGED_PENALTY;

285 av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,

286 "bits per sample change detected in adjacent frames\n");

287 }

288 if (child_fi->is_var_size != header_fi->is_var_size) {

289 /* Changing blocking strategy not allowed per the spec */

290 deduction += FLAC_HEADER_BASE_SCORE;

291 av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,

292 "blocking strategy change detected in adjacent frames\n");

293 }

294 if (child_fi->channels != header_fi->channels) {

295 deduction += FLAC_HEADER_CHANGED_PENALTY;

296 av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,

297 "number of channels change detected in adjacent frames\n");

298 }

299 return deduction;

300 }

301

302 static int check_header_mismatch(FLACParseContext *fpc,

303 FLACHeaderMarker *header,

304 FLACHeaderMarker *child,

305 int log_level_offset)

306 {

307 FLACFrameInfo *header_fi = &header->fi, *child_fi = &child->fi;

308 int deduction, deduction_expected = 0, i;

309 deduction = check_header_fi_mismatch(fpc, header_fi, child_fi,

310 log_level_offset);

311 /* Check sample and frame numbers. */

312 if ((child_fi->frame_or_sample_num - header_fi->frame_or_sample_num

313 != header_fi->blocksize) &&

314 (child_fi->frame_or_sample_num

315 != header_fi->frame_or_sample_num + 1)) {

316 FLACHeaderMarker *curr;

317 int expected_frame_num, expected_sample_num;

318 /* If there are frames in the middle we expect this deduction,

319 as they are probably valid and this one follows it */

320

321 expected_frame_num = expected_sample_num = header_fi->frame_or_sample_num;

322 curr = header;

323 while (curr != child) {

324 /* Ignore frames that failed all crc checks */

325 for (i = 0; i < FLAC_MAX_SEQUENTIAL_HEADERS; i++) {

326 if (curr->link_penalty[i] < FLAC_HEADER_CRC_FAIL_PENALTY) {

327 expected_frame_num++;

328 expected_sample_num += curr->fi.blocksize;

329 break;

330 }

331 }

332 curr = curr->next;

333 }

334

335 if (expected_frame_num == child_fi->frame_or_sample_num ||

336 expected_sample_num == child_fi->frame_or_sample_num)

337 deduction_expected = deduction ? 0 : 1;

338

339 deduction += FLAC_HEADER_CHANGED_PENALTY;

340 av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,

341 "sample/frame number mismatch in adjacent frames\n");

342 }

343

344 /* If we have suspicious headers, check the CRC between them */

345 if (deduction && !deduction_expected) {

346 FLACHeaderMarker *curr;

347 int read_len;

348 uint8_t *buf;

349 uint32_t crc = 1;

350 int inverted_test = 0;

351

352 /* Since CRC is expensive only do it if we haven't yet.

353 This assumes a CRC penalty is greater than all other check penalties */

354 curr = header->next;

355 for (i = 0; i < FLAC_MAX_SEQUENTIAL_HEADERS && curr != child; i++)

356 curr = curr->next;

357

358 if (header->link_penalty[i] < FLAC_HEADER_CRC_FAIL_PENALTY ||

359 header->link_penalty[i] == FLAC_HEADER_NOT_PENALIZED_YET) {

360 FLACHeaderMarker *start, *end;

361

362 /* Although overlapping chains are scored, the crc should never

363 have to be computed twice for a single byte. */

364 start = header;

365 end = child;

366 if (i > 0 &&

367 header->link_penalty[i - 1] >= FLAC_HEADER_CRC_FAIL_PENALTY) {

368 while (start->next != child)

369 start = start->next;

370 inverted_test = 1;

371 } else if (i > 0 &&

372 header->next->link_penalty[i-1] >=

373 FLAC_HEADER_CRC_FAIL_PENALTY ) {

374 end = header->next;

375 inverted_test = 1;

376 }

377

378 read_len = end->offset - start->offset;

379 buf = flac_fifo_read(fpc, start->offset, &read_len);

380 crc = av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf, read_len);

381 read_len = (end->offset - start->offset) - read_len;

382

383 if (read_len) {

384 buf = flac_fifo_read(fpc, end->offset - read_len, &read_len);

385 crc = av_crc(av_crc_get_table(AV_CRC_16_ANSI), crc, buf, read_len);

386 }

387 }

388

389 if (!crc ^ !inverted_test) {

390 deduction += FLAC_HEADER_CRC_FAIL_PENALTY;

391 av_log(fpc->avctx, AV_LOG_WARNING + log_level_offset,

392 "crc check failed from offset %i (frame %"PRId64") to %i (frame %"PRId64")\n",

393 header->offset, header_fi->frame_or_sample_num,

394 child->offset, child_fi->frame_or_sample_num);

395 }

396 }

397 return deduction;

398 }

399

400 /**

401 * Score a header.

402 *

403 * Give FLAC_HEADER_BASE_SCORE points to a frame for existing.

404 * If it has children, (subsequent frames of which the preceding CRC footer

405 * validates against this one,) then take the maximum score of the children,

406 * with a penalty of FLAC_HEADER_CHANGED_PENALTY applied for each change to

407 * bps, sample rate, channels, but not decorrelation mode, or blocksize,

408 * because it can change often.

409 **/

410 static int score_header(FLACParseContext *fpc, FLACHeaderMarker *header)

411 {

412 FLACHeaderMarker *child;

413 int dist = 0;

414 int child_score;

415 int base_score = FLAC_HEADER_BASE_SCORE;

416 if (header->max_score != FLAC_HEADER_NOT_SCORED_YET)

417 return header->max_score;

418

419 /* Modify the base score with changes from the last output header */

420 if (fpc->last_fi_valid) {

421 /* Silence the log since this will be repeated if selected */

422 base_score -= check_header_fi_mismatch(fpc, &fpc->last_fi, &header->fi,

423 AV_LOG_DEBUG);

424 }

425

426 header->max_score = base_score;

427

428 /* Check and compute the children's scores. */

429 child = header->next;

430 for (dist = 0; dist < FLAC_MAX_SEQUENTIAL_HEADERS && child; dist++) {

431 /* Look at the child's frame header info and penalize suspicious

432 changes between the headers. */

433 if (header->link_penalty[dist] == FLAC_HEADER_NOT_PENALIZED_YET) {

434 header->link_penalty[dist] = check_header_mismatch(fpc, header,

435 child, AV_LOG_DEBUG);

436 }

437 child_score = score_header(fpc, child) - header->link_penalty[dist];

438

439 if (FLAC_HEADER_BASE_SCORE + child_score > header->max_score) {

440 /* Keep the child because the frame scoring is dynamic. */

441 header->best_child = child;

442 header->max_score = base_score + child_score;

443 }

444 child = child->next;

445 }

446

447 return header->max_score;

448 }

449

450 static void score_sequences(FLACParseContext *fpc)

451 {

452 FLACHeaderMarker *curr;

453 int best_score = 0;//FLAC_HEADER_NOT_SCORED_YET;

454 /* First pass to clear all old scores. */

455 for (curr = fpc->headers; curr; curr = curr->next)

456 curr->max_score = FLAC_HEADER_NOT_SCORED_YET;

457

458 /* Do a second pass to score them all. */

459 for (curr = fpc->headers; curr; curr = curr->next) {

460 if (score_header(fpc, curr) > best_score) {

461 fpc->best_header = curr;

462 best_score = curr->max_score;

463 }

464 }

465 }

466

467 static int get_best_header(FLACParseContext* fpc, const uint8_t **poutbuf,

468 int *poutbuf_size)

469 {

470 FLACHeaderMarker *header = fpc->best_header;

471 FLACHeaderMarker *child = header->best_child;

472 if (!child) {

473 *poutbuf_size = av_fifo_size(fpc->fifo_buf) - header->offset;

474 } else {

475 *poutbuf_size = child->offset - header->offset;

476

477 /* If the child has suspicious changes, log them */

478 check_header_mismatch(fpc, header, child, 0);

479 }

480

481 if (header->fi.channels != fpc->avctx->channels ||

482 !fpc->avctx->channel_layout) {

483 fpc->avctx->channels = header->fi.channels;

484 ff_flac_set_channel_layout(fpc->avctx);

485 }

486 fpc->avctx->sample_rate = header->fi.samplerate;

487 fpc->pc->duration = header->fi.blocksize;

488 *poutbuf = flac_fifo_read_wrap(fpc, header->offset, *poutbuf_size,

489 &fpc->wrap_buf,

490 &fpc->wrap_buf_allocated_size);

491

492 fpc->best_header_valid = 0;

493 fpc->last_fi_valid = 1;

494 fpc->last_fi = header->fi;

495

496 /* Return the negative overread index so the client can compute pos.

497 This should be the amount overread to the beginning of the child */

498 if (child)

499 return child->offset - av_fifo_size(fpc->fifo_buf);

500 return 0;

501 }

502

503 static int flac_parse(AVCodecParserContext *s, AVCodecContext *avctx,

504 const uint8_t **poutbuf, int *poutbuf_size,

505 const uint8_t *buf, int buf_size)

506 {

507 FLACParseContext *fpc = s->priv_data;

508 FLACHeaderMarker *curr;

509 int nb_headers;

510 const uint8_t *read_end = buf;

511 const uint8_t *read_start = buf;

512

513 if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {

514 FLACFrameInfo fi;

515 if (frame_header_is_valid(avctx, buf, &fi))

516 s->duration = fi.blocksize;

517 *poutbuf = buf;

518 *poutbuf_size = buf_size;

519 return buf_size;

520 }

521

522 fpc->avctx = avctx;

523 if (fpc->best_header_valid)

524 return get_best_header(fpc, poutbuf, poutbuf_size);

525

526 /* If a best_header was found last call remove it with the buffer data. */

527 if (fpc->best_header && fpc->best_header->best_child) {

528 FLACHeaderMarker *temp;

529 FLACHeaderMarker *best_child = fpc->best_header->best_child;

530

531 /* Remove headers in list until the end of the best_header. */

532 for (curr = fpc->headers; curr != best_child; curr = temp) {

533 if (curr != fpc->best_header) {

534 av_log(avctx, AV_LOG_DEBUG,

535 "dropping low score %i frame header from offset %i to %i\n",

536 curr->max_score, curr->offset, curr->next->offset);

537 }

538 temp = curr->next;

539 av_freep(&curr->link_penalty);

540 av_free(curr);

541 fpc->nb_headers_buffered--;

542 }

543 /* Release returned data from ring buffer. */

544 av_fifo_drain(fpc->fifo_buf, best_child->offset);

545

546 /* Fix the offset for the headers remaining to match the new buffer. */

547 for (curr = best_child->next; curr; curr = curr->next)

548 curr->offset -= best_child->offset;

549

550 fpc->nb_headers_buffered--;

551 best_child->offset = 0;

552 fpc->headers = best_child;

553 if (fpc->nb_headers_buffered >= FLAC_MIN_HEADERS) {

554 fpc->best_header = best_child;

555 return get_best_header(fpc, poutbuf, poutbuf_size);

556 }

557 fpc->best_header = NULL;

558 } else if (fpc->best_header) {

559 /* No end frame no need to delete the buffer; probably eof */

560 FLACHeaderMarker *temp;

561

562 for (curr = fpc->headers; curr != fpc->best_header; curr = temp) {

563 temp = curr->next;

564 av_freep(&curr->link_penalty);

565 av_free(curr);

566 }

567 fpc->headers = fpc->best_header->next;

568 av_freep(&fpc->best_header->link_penalty);

569 av_freep(&fpc->best_header);

570 }

571

572 /* Find and score new headers. */

573 /* buf_size is to zero when padding, so check for this since we do */

574 /* not want to try to read more input once we have found the end. */

575 /* Note that as (non-modified) parameters, buf can be non-NULL, */

576 /* while buf_size is 0. */

577 while ((buf && buf_size && read_end < buf + buf_size &&

578 fpc->nb_headers_buffered < FLAC_MIN_HEADERS)

579 || ((!buf || !buf_size) && !fpc->end_padded)) {

580 int start_offset;

581

582 /* Pad the end once if EOF, to check the final region for headers. */

583 if (!buf || !buf_size) {

584 fpc->end_padded = 1;

585 buf_size = MAX_FRAME_HEADER_SIZE;

586 read_end = read_start + MAX_FRAME_HEADER_SIZE;

587 } else {

588 /* The maximum read size is the upper-bound of what the parser

589 needs to have the required number of frames buffered */

590 int nb_desired = FLAC_MIN_HEADERS - fpc->nb_headers_buffered + 1;

591 read_end = read_end + FFMIN(buf + buf_size - read_end,

592 nb_desired * FLAC_AVG_FRAME_SIZE);

593 }

594

595 /* Fill the buffer. */

596 if ( av_fifo_space(fpc->fifo_buf) < read_end - read_start

597 && av_fifo_realloc2(fpc->fifo_buf, (read_end - read_start) + 2*av_fifo_size(fpc->fifo_buf)) < 0) {

598 av_log(avctx, AV_LOG_ERROR,

599 "couldn't reallocate buffer of size %td\n",

600 (read_end - read_start) + av_fifo_size(fpc->fifo_buf));

601 goto handle_error;

602 }

603

604 if (buf && buf_size) {

605 av_fifo_generic_write(fpc->fifo_buf, (void*) read_start,

606 read_end - read_start, NULL);

607 } else {

608 int8_t pad[MAX_FRAME_HEADER_SIZE] = { 0 };

609 av_fifo_generic_write(fpc->fifo_buf, (void*) pad, sizeof(pad), NULL);

610 }

611

612 /* Tag headers and update sequences. */

613 start_offset = av_fifo_size(fpc->fifo_buf) -

614 ((read_end - read_start) + (MAX_FRAME_HEADER_SIZE - 1));

615 start_offset = FFMAX(0, start_offset);

616 nb_headers = find_new_headers(fpc, start_offset);

617

618 if (nb_headers < 0) {

619 av_log(avctx, AV_LOG_ERROR,

620 "find_new_headers couldn't allocate FLAC header\n");

621 goto handle_error;

622 }

623

624 fpc->nb_headers_buffered = nb_headers;

625 /* Wait till FLAC_MIN_HEADERS to output a valid frame. */

626 if (!fpc->end_padded && fpc->nb_headers_buffered < FLAC_MIN_HEADERS) {

627 if (buf && read_end < buf + buf_size) {

628 read_start = read_end;

629 continue;

630 } else {

631 goto handle_error;

632 }

633 }

634

635 /* If headers found, update the scores since we have longer chains. */

636 if (fpc->end_padded || fpc->nb_headers_found)

637 score_sequences(fpc);

638

639 /* restore the state pre-padding */

640 if (fpc->end_padded) {

641 int warp = fpc->fifo_buf->wptr - fpc->fifo_buf->buffer < MAX_FRAME_HEADER_SIZE;

642 /* HACK: drain the tail of the fifo */

643 fpc->fifo_buf->wptr -= MAX_FRAME_HEADER_SIZE;

644 fpc->fifo_buf->wndx -= MAX_FRAME_HEADER_SIZE;

645 if (warp) {

646 fpc->fifo_buf->wptr += fpc->fifo_buf->end -

647 fpc->fifo_buf->buffer;

648 }

649 buf_size = 0;

650 read_start = read_end = NULL;

651 }

652 }

653

654 curr = fpc->headers;

655 for (curr = fpc->headers; curr; curr = curr->next) {

656 if (curr->max_score > 0 &&

657 (!fpc->best_header || curr->max_score > fpc->best_header->max_score)) {

658 fpc->best_header = curr;

659 }

660 }

661

662 if (fpc->best_header) {

663 fpc->best_header_valid = 1;

664 if (fpc->best_header->offset > 0) {

665 /* Output a junk frame. */

666 av_log(avctx, AV_LOG_DEBUG, "Junk frame till offset %i\n",

667 fpc->best_header->offset);

668

669 /* Set duration to 0. It is unknown or invalid in a junk frame. */

670 s->duration = 0;

671 *poutbuf_size = fpc->best_header->offset;

672 *poutbuf = flac_fifo_read_wrap(fpc, 0, *poutbuf_size,

673 &fpc->wrap_buf,

674 &fpc->wrap_buf_allocated_size);

675 return buf_size ? (read_end - buf) : (fpc->best_header->offset -

676 av_fifo_size(fpc->fifo_buf));

677 }

678 if (!buf_size)

679 return get_best_header(fpc, poutbuf, poutbuf_size);

680 }

681

682 handle_error:

683 *poutbuf = NULL;

684 *poutbuf_size = 0;

685 return read_end - buf;

686 }

687

688 static av_cold int flac_parse_init(AVCodecParserContext *c)

689 {

690 FLACParseContext *fpc = c->priv_data;

691 fpc->pc = c;

692 /* There will generally be FLAC_MIN_HEADERS buffered in the fifo before

693 it drains. This is allocated early to avoid slow reallocation. */

694 fpc->fifo_buf = av_fifo_alloc(FLAC_AVG_FRAME_SIZE * (FLAC_MIN_HEADERS + 3));

695 if (!fpc->fifo_buf)

696 return AVERROR(ENOMEM);

697 return 0;

698 }

699

700 static void flac_parse_close(AVCodecParserContext *c)

701 {

702 FLACParseContext *fpc = c->priv_data;

703 FLACHeaderMarker *curr = fpc->headers, *temp;

704

705 while (curr) {

706 temp = curr->next;

707 av_freep(&curr->link_penalty);

708 av_free(curr);

709 curr = temp;

710 }

711 av_fifo_free(fpc->fifo_buf);

712 av_free(fpc->wrap_buf);

713 }

714

715 AVCodecParser ff_flac_parser = {

716 .codec_ids = { AV_CODEC_ID_FLAC },

717 .priv_data_size = sizeof(FLACParseContext),

718 .parser_init = flac_parse_init,

719 .parser_parse = flac_parse,

720 .parser_close = flac_parse_close,

721 };

Generated on Wed Jul 10 2013 23:47:58 for FFmpeg by doxygen 1.8.2