FFmpeg: libavformat/mpegenc.c Source File

189 * id (0xB8) audio, maximum P-STD for any MPEG audio (0xC0 to 0xC7) streams. If there are none set to 4096 (32x128). (P-STD_buffer_bound_scale = 0)

190 * id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)

191 * id (0xBF) private stream 2, NAV packs, set to 2x1024. */

192 if (s->is_dvd) {

193

194 int P_STD_max_video = 0;

195 int P_STD_max_mpeg_audio = 0;

196 int P_STD_max_mpeg_PS1 = 0;

197

198 for (i = 0; i < ctx->nb_streams; i++) {

199 StreamInfo *stream = ctx->streams[i]->priv_data;

200

201 id = stream->id;

202 if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {

203 P_STD_max_mpeg_PS1 = stream->max_buffer_size;

204 } else if (id >= 0xc0 && id <= 0xc7 &&

205 stream->max_buffer_size > P_STD_max_mpeg_audio) {

206 P_STD_max_mpeg_audio = stream->max_buffer_size;

207 } else if (id == 0xe0 &&

208 stream->max_buffer_size > P_STD_max_video) {

209 P_STD_max_video = stream->max_buffer_size;

210 }

211 }

212

213 /* video */

214 put_bits(&pb, 8, 0xb9); /* stream ID */

215 put_bits(&pb, 2, 3);

216 put_bits(&pb, 1, 1);

217 put_bits(&pb, 13, P_STD_max_video / 1024);

218

219 /* audio */

220 if (P_STD_max_mpeg_audio == 0)

221 P_STD_max_mpeg_audio = 4096;

222 put_bits(&pb, 8, 0xb8); /* stream ID */

223 put_bits(&pb, 2, 3);

224 put_bits(&pb, 1, 0);

225 put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);

226

227 /* private stream 1 */

228 put_bits(&pb, 8, 0xbd); /* stream ID */

229 put_bits(&pb, 2, 3);

230 put_bits(&pb, 1, 0);

231 put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);

232

233 /* private stream 2 */

234 put_bits(&pb, 8, 0xbf); /* stream ID */

235 put_bits(&pb, 2, 3);

236 put_bits(&pb, 1, 1);

237 put_bits(&pb, 13, 2);

238 } else {

239 /* audio stream info */

240 private_stream_coded = 0;

241 for (i = 0; i < ctx->nb_streams; i++) {

242 StreamInfo *stream = ctx->streams[i]->priv_data;

243

244 /* For VCDs, only include the stream info for the stream

245 * that the pack which contains this system belongs to.

246 * (see VCD standard p. IV-7) */

247 if (!s->is_vcd || stream->id == only_for_stream_id ||

248 only_for_stream_id == 0) {

249 id = stream->id;

250 if (id < 0xc0) {

251 /* special case for private streams (AC-3 uses that) */

252 if (private_stream_coded)

253 continue;

254 private_stream_coded = 1;

255 id = 0xbd;

256 }

257 put_bits(&pb, 8, id); /* stream ID */

258 put_bits(&pb, 2, 3);

259 if (id < 0xe0) {

260 /* audio */

261 put_bits(&pb, 1, 0);

262 put_bits(&pb, 13, stream->max_buffer_size / 128);

263 } else {

264 /* video */

265 put_bits(&pb, 1, 1);

266 put_bits(&pb, 13, stream->max_buffer_size / 1024);

267 }

268 }

269 }

270 }

271

272 flush_put_bits(&pb);

273 size = put_bytes_output(&pb);

274 /* patch packet size */

275 AV_WB16(buf + 4, size - 6);

276

277 return size;

278 }

279

280 static int get_system_header_size(AVFormatContext *ctx)

281 {

282 int buf_index, i, private_stream_coded;

283 StreamInfo *stream;

284 MpegMuxContext *s = ctx->priv_data;

285

286 if (s->is_dvd)

287 return 18; // DVD-Video system headers are 18 bytes fixed length.

288

289 buf_index = 12;

290 private_stream_coded = 0;

291 for (i = 0; i < ctx->nb_streams; i++) {

292 stream = ctx->streams[i]->priv_data;

293 if (stream->id < 0xc0) {

294 if (private_stream_coded)

295 continue;

296 private_stream_coded = 1;

297 }

298 buf_index += 3;

299 }

300 return buf_index;

301 }

302

303 static av_cold int mpeg_mux_init(AVFormatContext *ctx)

304 {

305 MpegMuxContext *s = ctx->priv_data;

306 int bitrate, i, mpa_id, mpv_id, h264_id, mps_id, ac3_id, dts_id, lpcm_id, j;

307 AVStream *st;

308 StreamInfo *stream;

309 int audio_bitrate;

310 int video_bitrate;

311

312 s->packet_number = 0;

313 s->is_vcd = (CONFIG_MPEG1VCD_MUXER && ctx->oformat == &ff_mpeg1vcd_muxer.p);

314 s->is_svcd = (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer.p);

315 s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER && ctx->oformat == &ff_mpeg2vob_muxer.p) ||

316 (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer.p) ||

317 (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer.p));

318 s->is_dvd = (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer.p);

319

320 if (ctx->packet_size) {

321 if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) {

322 av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n",

323 ctx->packet_size);

324 return AVERROR(EINVAL);

325 }

326 s->packet_size = ctx->packet_size;

327 } else

328 s->packet_size = 2048;

329 if (ctx->max_delay < 0) /* Not set by the caller */

330 ctx->max_delay = AV_TIME_BASE*7/10;

331

332 s->vcd_padding_bytes_written = 0;

333 s->vcd_padding_bitrate_num = 0;

334

335 s->audio_bound = 0;

336 s->video_bound = 0;

337

338 mpa_id = AUDIO_ID;

339 ac3_id = AC3_ID;

340 dts_id = DTS_ID;

341 mpv_id = VIDEO_ID;

342 h264_id = H264_ID;

343 mps_id = SUB_ID;

344 lpcm_id = LPCM_ID;

345

346 for (i = 0; i < ctx->nb_streams; i++) {

347 st = ctx->streams[i];

348 stream = av_mallocz(sizeof(StreamInfo));

349 if (!stream)

350 return AVERROR(ENOMEM);

351 st->priv_data = stream;

352

353 avpriv_set_pts_info(st, 64, 1, 90000);

354

355 switch (st->codecpar->codec_type) {

356 case AVMEDIA_TYPE_AUDIO:

357 if (!s->is_mpeg2 &&

358 (st->codecpar->codec_id == AV_CODEC_ID_AC3 ||

359 st->codecpar->codec_id == AV_CODEC_ID_DTS ||

360 st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE ||

361 st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD))

362 av_log(ctx, AV_LOG_WARNING,

363 "%s in MPEG-1 system streams is not widely supported, "

364 "consider using the vob or the dvd muxer "

365 "to force a MPEG-2 program stream.\n",

366 avcodec_get_name(st->codecpar->codec_id));

367 if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {

368 stream->id = ac3_id++;

369 } else if (st->codecpar->codec_id == AV_CODEC_ID_DTS) {

370 stream->id = dts_id++;

371 } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {

372 stream->id = lpcm_id++;

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

374 if (lpcm_freq_tab[j] == st->codecpar->sample_rate)

375 break;

376 }

377 if (j == 4) {

378 int sr;

379 av_log(ctx, AV_LOG_ERROR, "Invalid sampling rate for PCM stream.\n");

380 av_log(ctx, AV_LOG_INFO, "Allowed sampling rates:");

381 for (sr = 0; sr < 4; sr++)

382 av_log(ctx, AV_LOG_INFO, " %d", lpcm_freq_tab[sr]);

383 av_log(ctx, AV_LOG_INFO, "\n");

384 return AVERROR(EINVAL);

385 }

386 if (st->codecpar->ch_layout.nb_channels > 8) {

387 av_log(ctx, AV_LOG_ERROR, "At most 8 channels allowed for LPCM streams.\n");

388 return AVERROR(EINVAL);

389 }

390 stream->lpcm_header[0] = 0x0c;

391 stream->lpcm_header[1] = (st->codecpar->ch_layout.nb_channels - 1) | (j << 4);

392 stream->lpcm_header[2] = 0x80;

393 stream->lpcm_align = st->codecpar->ch_layout.nb_channels * 2;

394 } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD) {

395 int freq;

396

397 switch (st->codecpar->sample_rate) {

398 case 48000: freq = 0; break;

399 case 96000: freq = 1; break;

400 case 44100: freq = 2; break;

401 case 32000: freq = 3; break;

402 default:

403 av_log(ctx, AV_LOG_ERROR, "Unsupported sample rate.\n");

404 return AVERROR(EINVAL);

405 }

406

407 stream->lpcm_header[0] = 0x0c;

408 stream->lpcm_header[1] = (freq << 4) |

409 (((st->codecpar->bits_per_coded_sample - 16) / 4) << 6) |

410 st->codecpar->ch_layout.nb_channels - 1;

411 stream->lpcm_header[2] = 0x80;

412 stream->id = lpcm_id++;

413 stream->lpcm_align = st->codecpar->ch_layout.nb_channels * st->codecpar->bits_per_coded_sample / 8;

414 } else if (st->codecpar->codec_id == AV_CODEC_ID_MLP ||

415 st->codecpar->codec_id == AV_CODEC_ID_TRUEHD) {

416 av_log(ctx, AV_LOG_ERROR, "Support for muxing audio codec %s not implemented.\n",

417 avcodec_get_name(st->codecpar->codec_id));

418 return AVERROR_PATCHWELCOME;

419 } else if (st->codecpar->codec_id != AV_CODEC_ID_MP1 &&

420 st->codecpar->codec_id != AV_CODEC_ID_MP2 &&

421 st->codecpar->codec_id != AV_CODEC_ID_MP3) {

422 av_log(ctx, AV_LOG_ERROR, "Unsupported audio codec. Must be one of mp1, mp2, mp3, 16-bit pcm_dvd, pcm_s16be, ac3 or dts.\n");

423 return AVERROR(EINVAL);

424 } else {

425 stream->id = mpa_id++;

426 }

427

428 /* This value HAS to be used for VCD (see VCD standard, p. IV-7).

429 * Right now it is also used for everything else. */

430 stream->max_buffer_size = 4 * 1024;

431 s->audio_bound++;

432 break;

433 case AVMEDIA_TYPE_VIDEO: {

434 const AVPacketSideData *sd;

435 AVCPBProperties *props = NULL;

436 if (st->codecpar->codec_id == AV_CODEC_ID_H264)

437 stream->id = h264_id++;

438 else

439 stream->id = mpv_id++;

440

441 sd = av_packet_side_data_get(st->codecpar->coded_side_data,

442 st->codecpar->nb_coded_side_data,

443 AV_PKT_DATA_CPB_PROPERTIES);

444 if (sd)

445 props = (AVCPBProperties*)sd->data;

446 if (props && props->buffer_size)

447 stream->max_buffer_size = 6 * 1024 + props->buffer_size / 8;

448 else {

449 av_log(ctx, AV_LOG_WARNING,

450 "VBV buffer size not set, using default size of 230KB\n"

451 "If you want the mpeg file to be compliant to some specification\n"

452 "Like DVD, VCD or others, make sure you set the correct buffer size\n");

453 // FIXME: this is probably too small as default

454 stream->max_buffer_size = 230 * 1024;

455 }

456 if (stream->max_buffer_size > 1024 * 8191) {

457 av_log(ctx, AV_LOG_WARNING, "buffer size %d, too large\n", stream->max_buffer_size);

458 stream->max_buffer_size = 1024 * 8191;

459 }

460 s->video_bound++;

461 break;

462 }

463 case AVMEDIA_TYPE_SUBTITLE:

464 stream->id = mps_id++;

465 stream->max_buffer_size = 16 * 1024;

466 break;

467 default:

468 av_log(ctx, AV_LOG_ERROR, "Invalid media type %s for output stream #%d\n",

469 av_get_media_type_string(st->codecpar->codec_type), i);

470 return AVERROR(EINVAL);

471 }

472 stream->fifo = av_fifo_alloc2(16, 1, 0);

473 if (!stream->fifo)

474 return AVERROR(ENOMEM);

475 }

476 bitrate = 0;

477 audio_bitrate = 0;

478 video_bitrate = 0;

479 for (i = 0; i < ctx->nb_streams; i++) {

480 const AVPacketSideData *sd;

481 AVCPBProperties *props = NULL;

482 int codec_rate;

483 st = ctx->streams[i];

484 stream = (StreamInfo *)st->priv_data;

485

486 sd = av_packet_side_data_get(st->codecpar->coded_side_data,

487 st->codecpar->nb_coded_side_data,

488 AV_PKT_DATA_CPB_PROPERTIES);

489 if (sd)

490 props = (AVCPBProperties*)sd->data;

491 if (props)

492 codec_rate = props->max_bitrate;

493 else

494 codec_rate = st->codecpar->bit_rate;

495

496 if (!codec_rate)

497 codec_rate = (1 << 21) * 8 * 50 / ctx->nb_streams;

498

499 bitrate += codec_rate;

500

501 if ((stream->id & 0xe0) == AUDIO_ID)

502 audio_bitrate += codec_rate;

503 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)

504 video_bitrate += codec_rate;

505 }

506

507 if (s->user_mux_rate) {

508 s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);

509 } else {

510 /* we increase slightly the bitrate to take into account the

511 * headers. XXX: compute it exactly */

512 bitrate += bitrate / 20;

513 bitrate += 10000;

514 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);

515 if (s->mux_rate >= (1<<22)) {

516 av_log(ctx, AV_LOG_WARNING, "mux rate %d is too large\n", s->mux_rate);

517 s->mux_rate = (1<<22) - 1;

518 }

519 }

520

521 if (s->is_vcd) {

522 int64_t overhead_rate;

523

524 /* The VCD standard mandates that the mux_rate field is 3528

525 * (see standard p. IV-6).

526 * The value is actually "wrong", i.e. if you calculate

527 * it using the normal formula and the 75 sectors per second transfer

528 * rate you get a different value because the real pack size is 2324,

529 * not 2352. But the standard explicitly specifies that the mux_rate

530 * field in the header must have this value. */

531 // s->mux_rate = 2352 * 75 / 50; /* = 3528 */

532

533 /* The VCD standard states that the muxed stream must be

534 * exactly 75 packs / second (the data rate of a single speed cdrom).

535 * Since the video bitrate (probably 1150000 bits/sec) will be below

536 * the theoretical maximum we have to add some padding packets

537 * to make up for the lower data rate.

538 * (cf. VCD standard p. IV-6 ) */

539

540 /* Add the header overhead to the data rate.

541 * 2279 data bytes per audio pack, 2294 data bytes per video pack */

542 overhead_rate = audio_bitrate * 2294LL * (2324 - 2279);

543 overhead_rate += video_bitrate * 2279LL * (2324 - 2294);

544

545 /* Add padding so that the full bitrate is 2324*75 bytes/sec */

546 s->vcd_padding_bitrate_num = (2324LL * 75 * 8 - bitrate) * 2279 * 2294 - overhead_rate;

547 #define VCD_PADDING_BITRATE_DEN (2279 * 2294)

548 }

549

550 if (s->is_vcd || s->is_mpeg2)

551 /* every packet */

552 s->pack_header_freq = 1;

553 else

554 /* every 2 seconds */

555 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;

556

557 /* the above seems to make pack_header_freq zero sometimes */

558 if (s->pack_header_freq == 0)

559 s->pack_header_freq = 1;

560

561 if (s->is_mpeg2)

562 /* every 200 packets. Need to look at the spec. */

563 s->system_header_freq = s->pack_header_freq * 40;

564 else if (s->is_vcd)

565 /* the standard mandates that there are only two system headers

566 * in the whole file: one in the first packet of each stream.

567 * (see standard p. IV-7 and IV-8) */

568 s->system_header_freq = 0x7fffffff;

569 else

570 s->system_header_freq = s->pack_header_freq * 5;

571

572 for (i = 0; i < ctx->nb_streams; i++) {

573 stream = ctx->streams[i]->priv_data;

574 stream->packet_number = 0;

575 }

576 s->system_header_size = get_system_header_size(ctx);

577 s->last_scr = AV_NOPTS_VALUE;

578 return 0;

579 }

580

581 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)

582 {

583 avio_w8(pb, (id << 4) | (((timestamp >> 30) & 0x07) << 1) | 1);

584 avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));

585 avio_wb16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));

586 }

587

588 /* return the number of padding bytes that should be inserted into

589 * the multiplexed stream. */

590 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)

591 {

592 MpegMuxContext *s = ctx->priv_data;

593 int pad_bytes = 0;

594

595 if (s->vcd_padding_bitrate_num > 0 && pts != AV_NOPTS_VALUE) {

596 int64_t full_pad_bytes;

597

598 // FIXME: this is wrong

599 full_pad_bytes =

600 av_rescale(s->vcd_padding_bitrate_num, pts, 90000LL * 8 * VCD_PADDING_BITRATE_DEN);

601 pad_bytes = (int)(full_pad_bytes - s->vcd_padding_bytes_written);

602

603 if (pad_bytes < 0)

604 /* might happen if we have already padded to a later timestamp. This

605 * can occur if another stream has already advanced further. */

606 pad_bytes = 0;

607 }

608

609 return pad_bytes;

610 }

611

612 /* Write an MPEG padding packet header. */

613 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,

614 int packet_bytes)

615 {

616 MpegMuxContext *s = ctx->priv_data;

617

618 avio_wb32(pb, PADDING_STREAM);

619 avio_wb16(pb, packet_bytes - 6);

620 if (!s->is_mpeg2) {

621 avio_w8(pb, 0x0f);

622 packet_bytes -= 7;

623 } else

624 packet_bytes -= 6;

625

626 ffio_fill(pb, 0xff, packet_bytes);

627 }

628

629 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len)

630 {

631 int nb_frames = 0;

632 PacketDesc *pkt_desc = stream->premux_packet;

633

634 while (len > 0) {

635 if (pkt_desc->size == pkt_desc->unwritten_size)

636 nb_frames++;

637 len -= pkt_desc->unwritten_size;

638 pkt_desc = pkt_desc->next;

639 }

640

641 return nb_frames;

642 }

643

644 static int fifo_avio_wrapper(void *opaque, void *buf, size_t *nb_elems)

645 {

646 avio_write(opaque, buf, *nb_elems);

647 return 0;

648 }

649

650 /* flush the packet on stream stream_index */

651 static int flush_packet(AVFormatContext *ctx, int stream_index,

652 int64_t pts, int64_t dts, int64_t scr, int trailer_size)

653 {

654 MpegMuxContext *s = ctx->priv_data;

655 StreamInfo *stream = ctx->streams[stream_index]->priv_data;

656 uint8_t *buf_ptr;

657 int size, payload_size, startcode, id, stuffing_size, header_len;

658 int packet_size;

659 uint8_t buffer[128];

660 int zero_trail_bytes = 0;

661 int pad_packet_bytes = 0;

662 int pes_flags;

663 /* "general" pack without data specific to one stream? */

664 int general_pack = 0;

665 int nb_frames;

666

667 id = stream->id;

668

669 av_log(ctx, AV_LOG_TRACE, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);

670

671 buf_ptr = buffer;

672

673 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {

674 /* output pack and systems header if needed */

675 size = put_pack_header(ctx, buf_ptr, scr);

676 buf_ptr += size;

677 s->last_scr = scr;

678

679 if (s->is_vcd) {

680 /* there is exactly one system header for each stream in a VCD MPEG,

681 * One in the very first video packet and one in the very first

682 * audio packet (see VCD standard p. IV-7 and IV-8). */

683

684 if (stream->packet_number == 0) {

685 size = put_system_header(ctx, buf_ptr, id);

686 buf_ptr += size;

687 }

688 } else if (s->is_dvd) {

689 if (stream->align_iframe || s->packet_number == 0) {

690 int PES_bytes_to_fill = s->packet_size - size - 10;

691

692 if (pts != AV_NOPTS_VALUE) {

693 if (dts != pts)

694 PES_bytes_to_fill -= 5 + 5;

695 else

696 PES_bytes_to_fill -= 5;

697 }

698

699 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {

700 size = put_system_header(ctx, buf_ptr, 0);

701 buf_ptr += size;

702 size = buf_ptr - buffer;

703 avio_write(ctx->pb, buffer, size);

704

705 avio_wb32(ctx->pb, PRIVATE_STREAM_2);

706 avio_wb16(ctx->pb, 0x03d4); // length

707 avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI

708 ffio_fill(ctx->pb, 0x00, 979);

709

710 avio_wb32(ctx->pb, PRIVATE_STREAM_2);

711 avio_wb16(ctx->pb, 0x03fa); // length

712 avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI

713 ffio_fill(ctx->pb, 0x00, 1017);

714

715 memset(buffer, 0, 128);

716 buf_ptr = buffer;

717 s->packet_number++;

718 stream->align_iframe = 0;

719 // FIXME: rounding and first few bytes of each packet

720 scr += s->packet_size * 90000LL /

721 (s->mux_rate * 50LL);

722 size = put_pack_header(ctx, buf_ptr, scr);

723 s->last_scr = scr;

724 buf_ptr += size;

725 /* GOP Start */

726 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {

727 pad_packet_bytes = PES_bytes_to_fill -

728 stream->bytes_to_iframe;

729 }

730 }

731 } else {

732 if ((s->packet_number % s->system_header_freq) == 0) {

733 size = put_system_header(ctx, buf_ptr, 0);

734 buf_ptr += size;

735 }

736 }

737 }

738 size = buf_ptr - buffer;

739 avio_write(ctx->pb, buffer, size);

740

741 packet_size = s->packet_size - size;

742

743 if (s->is_vcd && (id & 0xe0) == AUDIO_ID)

744 /* The VCD standard demands that 20 zero bytes follow

745 * each audio pack (see standard p. IV-8). */

746 zero_trail_bytes += 20;

747

748 if ((s->is_vcd && stream->packet_number == 0) ||

749 (s->is_svcd && s->packet_number == 0)) {

750 /* for VCD the first pack of each stream contains only the pack header,

751 * the system header and lots of padding (see VCD standard p. IV-6).

752 * In the case of an audio pack, 20 zero bytes are also added at

753 * the end. */

754 /* For SVCD we fill the very first pack to increase compatibility with

755 * some DVD players. Not mandated by the standard. */

756 if (s->is_svcd)

757 /* the system header refers to both streams and no stream data */

758 general_pack = 1;

759 pad_packet_bytes = packet_size - zero_trail_bytes;

760 }

761

762 packet_size -= pad_packet_bytes + zero_trail_bytes;

763

764 if (packet_size > 0) {

765 size_t fifo_data;

766 /* packet header size */

767 packet_size -= 6;

768

769 /* packet header */

770 if (s->is_mpeg2) {

771 header_len = 3;

772 if (stream->packet_number == 0)

773 header_len += 3; /* PES extension */

774 header_len += 1; /* obligatory stuffing byte */

775 } else {

776 header_len = 0;

777 }

778 if (pts != AV_NOPTS_VALUE) {

779 if (dts != pts)

780 header_len += 5 + 5;

781 else

782 header_len += 5;

783 } else {

784 if (!s->is_mpeg2)

785 header_len++;

786 }

787

788 payload_size = packet_size - header_len;

789 if (id < 0xc0) {

790 startcode = PRIVATE_STREAM_1;

791 payload_size -= 1;

792 if (id >= 0x40) {

793 payload_size -= 3;

794 if (id >= 0xa0)

795 payload_size -= 3;

796 }

797 } else {

798 startcode = 0x100 + id;

799 }

800

801 stuffing_size = payload_size - av_fifo_can_read(stream->fifo);

802

803 // first byte does not fit -> reset pts/dts + stuffing

804 if (payload_size <= trailer_size && pts != AV_NOPTS_VALUE) {

805 int timestamp_len = 0;

806 if (dts != pts)

807 timestamp_len += 5;

808 if (pts != AV_NOPTS_VALUE)

809 timestamp_len += s->is_mpeg2 ? 5 : 4;

810 pts =

811 dts = AV_NOPTS_VALUE;

812 header_len -= timestamp_len;

813 if (s->is_dvd && stream->align_iframe) {

814 pad_packet_bytes += timestamp_len;

815 packet_size -= timestamp_len;

816 } else {

817 payload_size += timestamp_len;

818 }

819 stuffing_size += timestamp_len;

820 if (payload_size > trailer_size)

821 stuffing_size += payload_size - trailer_size;

822 }

823

824 // can't use padding, so use stuffing

825 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) {

826 packet_size += pad_packet_bytes;

827 payload_size += pad_packet_bytes; // undo the previous adjustment

828 if (stuffing_size < 0)

829 stuffing_size = pad_packet_bytes;

830 else

831 stuffing_size += pad_packet_bytes;

832 pad_packet_bytes = 0;

833 }

834

835 if (stuffing_size < 0)

836 stuffing_size = 0;

837

838 if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {

839 if (payload_size < av_fifo_can_read(stream->fifo))

840 stuffing_size += payload_size % stream->lpcm_align;

841 }

842

843 if (stuffing_size > 16) { /* <=16 for MPEG-1, <=32 for MPEG-2 */

844 pad_packet_bytes += stuffing_size;

845 packet_size -= stuffing_size;

846 payload_size -= stuffing_size;

847 stuffing_size = 0;

848 }

849

850 nb_frames = get_nb_frames(ctx, stream, payload_size - stuffing_size);

851

852 avio_wb32(ctx->pb, startcode);

853

854 avio_wb16(ctx->pb, packet_size);

855

856 if (!s->is_mpeg2)

857 ffio_fill(ctx->pb, 0xff, stuffing_size);

858

859 if (s->is_mpeg2) {

860 avio_w8(ctx->pb, 0x80); /* mpeg2 id */

861

862 pes_flags = 0;

863

864 if (pts != AV_NOPTS_VALUE) {

865 pes_flags |= 0x80;

866 if (dts != pts)

867 pes_flags |= 0x40;

868 }

869

870 /* Both the MPEG-2 and the SVCD standards demand that the

871 * P-STD_buffer_size field be included in the first packet of

872 * every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2

873 * and MPEG-2 standard 2.7.7) */

874 if (stream->packet_number == 0)

875 pes_flags |= 0x01;

876

877 avio_w8(ctx->pb, pes_flags); /* flags */

878 avio_w8(ctx->pb, header_len - 3 + stuffing_size);

879

880 if (pes_flags & 0x80) /* write pts */

881 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);

882 if (pes_flags & 0x40) /* write dts */

883 put_timestamp(ctx->pb, 0x01, dts);

884

885 if (pes_flags & 0x01) { /* write pes extension */

886 avio_w8(ctx->pb, 0x10); /* flags */

887

888 /* P-STD buffer info */

889 if ((id & 0xe0) == AUDIO_ID)

890 avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size / 128);

891 else

892 avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size / 1024);

893 }

894 } else {

895 if (pts != AV_NOPTS_VALUE) {

896 if (dts != pts) {

897 put_timestamp(ctx->pb, 0x03, pts);

898 put_timestamp(ctx->pb, 0x01, dts);

899 } else {

900 put_timestamp(ctx->pb, 0x02, pts);

901 }

902 } else {

903 avio_w8(ctx->pb, 0x0f);

904 }

905 }

906

907 if (s->is_mpeg2) {

908 /* special stuffing byte that is always written

909 * to prevent accidental generation of start codes. */

910 avio_w8(ctx->pb, 0xff);

911

912 ffio_fill(ctx->pb, 0xff, stuffing_size);

913 }

914

915 if (startcode == PRIVATE_STREAM_1) {

916 avio_w8(ctx->pb, id);

917 if (id >= 0xa0) {

918 /* LPCM (XXX: check nb_frames) */

919 avio_w8(ctx->pb, 7);

920 avio_wb16(ctx->pb, 4); /* skip 3 header bytes */

921 avio_w8(ctx->pb, stream->lpcm_header[0]);

922 avio_w8(ctx->pb, stream->lpcm_header[1]);

923 avio_w8(ctx->pb, stream->lpcm_header[2]);

924 } else if (id >= 0x40) {

925 /* AC-3 */

926 avio_w8(ctx->pb, nb_frames);

927 avio_wb16(ctx->pb, trailer_size + 1);

928 }

929 }

930

931 /* output data */

932 fifo_data = payload_size - stuffing_size;

933 av_assert0(fifo_data <= av_fifo_can_read(stream->fifo));

934 av_fifo_read_to_cb(stream->fifo, fifo_avio_wrapper, ctx->pb, &fifo_data);

935 stream->bytes_to_iframe -= fifo_data;

936 } else {

937 payload_size =

938 stuffing_size = 0;

939 }

940

941 if (pad_packet_bytes > 0)

942 put_padding_packet(ctx, ctx->pb, pad_packet_bytes);

943

944 ffio_fill(ctx->pb, 0x00, zero_trail_bytes);

945

946 avio_write_marker(ctx->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_FLUSH_POINT);

947

948 s->packet_number++;

949

950 /* only increase the stream packet number if this pack actually contains

951 * something that is specific to this stream! I.e. a dedicated header

952 * or some data. */

953 if (!general_pack)

954 stream->packet_number++;

955

956 return payload_size - stuffing_size;

957 }

958

959 static void put_vcd_padding_sector(AVFormatContext *ctx)

960 {

961 /* There are two ways to do this padding: writing a sector/pack

962 * of 0 values, or writing an MPEG padding pack. Both seem to

963 * work with most decoders, BUT the VCD standard only allows a 0-sector

964 * (see standard p. IV-4, IV-5).

965 * So a 0-sector it is... */

966

967 MpegMuxContext *s = ctx->priv_data;

968

969 ffio_fill(ctx->pb, 0, s->packet_size);

970

971 s->vcd_padding_bytes_written += s->packet_size;

972

973 avio_write_marker(ctx->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_FLUSH_POINT);

974

975 /* increasing the packet number is correct. The SCR of the following packs

976 * is calculated from the packet_number and it has to include the padding

977 * sector (it represents the sector index, not the MPEG pack index)

978 * (see VCD standard p. IV-6) */

979 s->packet_number++;

980 }

981

982 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)

983 {

984 int i;

985

986 for (i = 0; i < ctx->nb_streams; i++) {

987 AVStream *st = ctx->streams[i];

988 StreamInfo *stream = st->priv_data;

989 PacketDesc *pkt_desc;

990

991 while ((pkt_desc = stream->predecode_packet) &&

992 scr > pkt_desc->dts) { // FIXME: > vs >=

993 if (stream->buffer_index < pkt_desc->size ||

994 stream->predecode_packet == stream->premux_packet) {

995 av_log(ctx, AV_LOG_ERROR,

996 "buffer underflow st=%d bufi=%d size=%d\n",

997 i, stream->buffer_index, pkt_desc->size);

998 break;

999 }

1000 stream->buffer_index -= pkt_desc->size;

1001 stream->predecode_packet = pkt_desc->next;

1002 if (!stream->predecode_packet)

1003 stream->last_packet = NULL;

1004 av_freep(&pkt_desc);

1005 }

1006 }

1007

1008 return 0;

1009 }

1010

1011 static int output_packet(AVFormatContext *ctx, int flush)

1012 {

1013 MpegMuxContext *s = ctx->priv_data;

1014 AVStream *st;

1015 StreamInfo *stream;

1016 int i, avail_space = 0, es_size, trailer_size;

1017 int best_i = -1;

1018 int best_score = INT_MIN;

1019 int ignore_constraints = 0;

1020 int ignore_delay = 0;

1021 int64_t scr = s->last_scr;

1022 PacketDesc *timestamp_packet;

1023 const int64_t max_delay = av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);

1024

1025 retry:

1026 for (i = 0; i < ctx->nb_streams; i++) {

1027 AVStream *st = ctx->streams[i];

1028 StreamInfo *stream = st->priv_data;

1029 const size_t avail_data = av_fifo_can_read(stream->fifo);

1030 const int space = stream->max_buffer_size - stream->buffer_index;

1031 int rel_space = 1024LL * space / stream->max_buffer_size;

1032 PacketDesc *next_pkt = stream->premux_packet;

1033

1034 /* for subtitle, a single PES packet must be generated,

1035 * so we flush after every single subtitle packet */

1036 if (s->packet_size > avail_data && !flush

1037 && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)

1038 return 0;

1039 if (avail_data == 0)

1040 continue;

1041 av_assert0(avail_data > 0);

1042

1043 if (space < s->packet_size && !ignore_constraints)

1044 continue;

1045

1046 if (next_pkt && next_pkt->dts - scr > max_delay && !ignore_delay)

1047 continue;

1048 if ( stream->predecode_packet

1049 && stream->predecode_packet->size > stream->buffer_index)

1050 rel_space += 1<<28;

1051 if (rel_space > best_score) {

1052 best_score = rel_space;

1053 best_i = i;

1054 avail_space = space;

1055 }

1056 }

1057

1058 if (best_i < 0) {

1059 int64_t best_dts = INT64_MAX;

1060 int has_premux = 0;

1061

1062 for (i = 0; i < ctx->nb_streams; i++) {

1063 AVStream *st = ctx->streams[i];

1064 StreamInfo *stream = st->priv_data;

1065 PacketDesc *pkt_desc = stream->predecode_packet;

1066 if (pkt_desc && pkt_desc->dts < best_dts)

1067 best_dts = pkt_desc->dts;

1068 has_premux |= !!stream->premux_packet;

1069 }

1070

1071 if (best_dts < INT64_MAX) {

1072 av_log(ctx, AV_LOG_TRACE, "bumping scr, scr:%f, dts:%f\n",

1073 scr / 90000.0, best_dts / 90000.0);

1074

1075 if (scr >= best_dts + 1 && !ignore_constraints) {

1076 av_log(ctx, AV_LOG_ERROR,

1077 "packet too large, ignoring buffer limits to mux it\n");

1078 ignore_constraints = 1;

1079 }

1080 scr = FFMAX(best_dts + 1, scr);

1081 if (remove_decoded_packets(ctx, scr) < 0)

1082 return -1;

1083 } else if (has_premux && flush) {

1084 av_log(ctx, AV_LOG_ERROR,

1085 "delay too large, ignoring ...\n");

1086 ignore_delay = 1;

1087 ignore_constraints = 1;

1088 } else

1089 return 0;

1090

1091 goto retry;

1092 }

1093

1094 av_assert0(best_i >= 0);

1095

1096 st = ctx->streams[best_i];

1097 stream = st->priv_data;

1098

1099 av_assert0(av_fifo_can_read(stream->fifo) > 0);

1100

1101 av_assert0(avail_space >= s->packet_size || ignore_constraints);

1102

1103 timestamp_packet = stream->premux_packet;

1104 if (timestamp_packet->unwritten_size == timestamp_packet->size) {

1105 trailer_size = 0;

1106 } else {

1107 trailer_size = timestamp_packet->unwritten_size;

1108 timestamp_packet = timestamp_packet->next;

1109 }

1110

1111 if (timestamp_packet) {

1112 av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f scr:%f stream:%d\n",

1113 timestamp_packet->dts / 90000.0,

1114 timestamp_packet->pts / 90000.0,

1115 scr / 90000.0, best_i);

1116 es_size = flush_packet(ctx, best_i, timestamp_packet->pts,

1117 timestamp_packet->dts, scr, trailer_size);

1118 } else {

1119 av_assert0(av_fifo_can_read(stream->fifo) == trailer_size);

1120 es_size = flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr,

1121 trailer_size);

1122 }

1123

1124 if (s->is_vcd) {

1125 /* Write one or more padding sectors, if necessary, to reach

1126 * the constant overall bitrate. */

1127 int vcd_pad_bytes;

1128

1129 // FIXME: pts cannot be correct here

1130 while ((vcd_pad_bytes = get_vcd_padding_size(ctx, stream->premux_packet->pts)) >= s->packet_size) {

1131 put_vcd_padding_sector(ctx);

1132 // FIXME: rounding and first few bytes of each packet

1133 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);

1134 }

1135 }

1136

1137 stream->buffer_index += es_size;

1138 // FIXME: rounding and first few bytes of each packet

1139 s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);

1140

1141 while (stream->premux_packet &&

1142 stream->premux_packet->unwritten_size <= es_size) {

1143 es_size -= stream->premux_packet->unwritten_size;

1144 stream->premux_packet = stream->premux_packet->next;

1145 }

1146 if (es_size) {

1147 av_assert0(stream->premux_packet);

1148 stream->premux_packet->unwritten_size -= es_size;

1149 }

1150

1151 if (remove_decoded_packets(ctx, s->last_scr) < 0)

1152 return -1;

1153

1154 return 1;

1155 }

1156

1157 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)

1158 {

1159 int stream_index = pkt->stream_index;

1160 int size = pkt->size;

1161 const uint8_t *buf = pkt->data;

1162 MpegMuxContext *s = ctx->priv_data;

1163 AVStream *st = ctx->streams[stream_index];

1164 StreamInfo *stream = st->priv_data;

1165 int64_t pts, dts;

1166 PacketDesc *pkt_desc;

1167 int preload, ret;

1168 size_t can_write;

1169 const int is_iframe = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&

1170 (pkt->flags & AV_PKT_FLAG_KEY);

1171

1172 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);

1173

1174 pts = pkt->pts;

1175 dts = pkt->dts;

1176

1177 if (s->last_scr == AV_NOPTS_VALUE) {

1178 if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {

1179 if (dts != AV_NOPTS_VALUE)

1180 s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);

1181 s->last_scr = 0;

1182 } else {

1183 s->last_scr = dts - preload;

1184 s->preload = 0;

1185 }

1186 preload = av_rescale(s->preload, 90000, AV_TIME_BASE);

1187 av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);

1188 }

1189

1190 if (dts != AV_NOPTS_VALUE) dts += preload;

1191 if (pts != AV_NOPTS_VALUE) pts += preload;

1192

1193 av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",

1194 dts / 90000.0, pts / 90000.0, pkt->flags,

1195 pkt->stream_index, pts != AV_NOPTS_VALUE);

1196

1197 if (st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD) {

1198 if (size < 3) {

1199 av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n", size);

1200 return AVERROR(EINVAL);

1201 }

1202

1203 /* Skip first 3 bytes of packet data, which comprise PCM header

1204 and will be written fresh by this muxer. */

1205 buf += 3;

1206 size -= 3;

1207 }

1208

1209 /* Enlarge the FIFO before adding a new PacketDesc

1210 * in order to avoid inconsistencies on failure. */

1211 can_write = av_fifo_can_write(stream->fifo);

1212 if (can_write < size) {

1213 ret = av_fifo_grow2(stream->fifo, size - can_write);

1214 if (ret < 0)

1215 return ret;

1216 }

1217 pkt_desc = av_mallocz(sizeof(PacketDesc));

1218 if (!pkt_desc)

1219 return AVERROR(ENOMEM);

1220 if (!stream->predecode_packet) {

1221 stream->predecode_packet = pkt_desc;

1222 } else

1223 stream->last_packet->next = pkt_desc;

1224 stream->last_packet = pkt_desc;

1225 if (!stream->premux_packet)

1226 stream->premux_packet = pkt_desc;

1227 pkt_desc->pts = pts;

1228 pkt_desc->dts = dts;

1229 pkt_desc->unwritten_size =

1230 pkt_desc->size = size;

1231

1232 if (s->is_dvd) {

1233 // min VOBU length 0.4 seconds (mpucoder)

1234 if (is_iframe &&

1235 (s->packet_number == 0 || pts != AV_NOPTS_VALUE &&

1236 (pts - stream->vobu_start_pts >= 36000))) {

1237 stream->bytes_to_iframe = av_fifo_can_read(stream->fifo);

1238 stream->align_iframe = 1;

1239 stream->vobu_start_pts = pts;

1240 }

1241 }

1242

1243 av_fifo_write(stream->fifo, buf, size);

1244

1245 for (;;) {

1246 int ret = output_packet(ctx, 0);

1247 if (ret <= 0)

1248 return ret;

1249 }

1250 }

1251

1252 static int mpeg_mux_end(AVFormatContext *ctx)

1253 {

1254 StreamInfo *stream;

1255 int i;

1256

1257 for (;;) {

1258 int ret = output_packet(ctx, 1);

1259 if (ret < 0)

1260 return ret;

1261 else if (ret == 0)

1262 break;

1263 }

1264

1265 /* End header according to MPEG-1 systems standard. We do not write

1266 * it as it is usually not needed by decoders and because it

1267 * complicates MPEG stream concatenation. */

1268 // avio_wb32(ctx->pb, ISO_11172_END_CODE);

1269

1270 for (i = 0; i < ctx->nb_streams; i++) {

1271 stream = ctx->streams[i]->priv_data;

1272

1273 av_assert0(av_fifo_can_read(stream->fifo) == 0);

1274 }

1275 return 0;

1276 }

1277

1278 static void mpeg_mux_deinit(AVFormatContext *ctx)

1279 {

1280 for (int i = 0; i < ctx->nb_streams; i++) {

1281 StreamInfo *stream = ctx->streams[i]->priv_data;

1282 if (!stream)

1283 continue;

1284 for (PacketDesc *pkt = stream->predecode_packet; pkt; ) {

1285 PacketDesc *tmp = pkt->next;

1286 av_free(pkt);

1287 pkt = tmp;

1288 }

1289 av_fifo_freep2(&stream->fifo);

1290 }

1291 }

1292

1293 #define OFFSET(x) offsetof(MpegMuxContext, x)

1294 #define E AV_OPT_FLAG_ENCODING_PARAM

1295 static const AVOption options[] = {

1296 { "muxrate", "mux rate as bits/s", OFFSET(user_mux_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, ((1<<22) - 1) * (8 * 50), E },

1297 { "preload", "initial demux-decode delay in microseconds", OFFSET(preload), AV_OPT_TYPE_INT, { .i64 = 500000 }, 0, INT_MAX, E },

1298 { NULL },

1299 };

1300

1301 static const AVClass mpeg_class = {

1302 .class_name = "mpeg/(s)vcd/vob/dvd muxer",

1303 .item_name = av_default_item_name,

1304 .version = LIBAVUTIL_VERSION_INT,

1305 .option = options,

1306 };

1307

1308 #if CONFIG_MPEG1SYSTEM_MUXER

1309 const FFOutputFormat ff_mpeg1system_muxer = {

1310 .p.name = "mpeg",

1311 .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),

1312 .p.mime_type = "video/mpeg",

1313 .p.extensions = "mpg,mpeg",

1314 .priv_data_size = sizeof(MpegMuxContext),

1315 .p.audio_codec = AV_CODEC_ID_MP2,

1316 .p.video_codec = AV_CODEC_ID_MPEG1VIDEO,

1317 .write_header = mpeg_mux_init,

1318 .write_packet = mpeg_mux_write_packet,

1319 .write_trailer = mpeg_mux_end,

1320 .deinit = mpeg_mux_deinit,

1321 .p.priv_class = &mpeg_class,

1322 };

1323 #endif

1324

1325 #if CONFIG_MPEG1VCD_MUXER

1326 const FFOutputFormat ff_mpeg1vcd_muxer = {

1327 .p.name = "vcd",

1328 .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),

1329 .p.mime_type = "video/mpeg",

1330 .priv_data_size = sizeof(MpegMuxContext),

1331 .p.audio_codec = AV_CODEC_ID_MP2,

1332 .p.video_codec = AV_CODEC_ID_MPEG1VIDEO,

1333 .write_header = mpeg_mux_init,

1334 .write_packet = mpeg_mux_write_packet,

1335 .write_trailer = mpeg_mux_end,

1336 .deinit = mpeg_mux_deinit,

1337 .p.priv_class = &mpeg_class,

1338 };

1339 #endif

1340

1341 #if CONFIG_MPEG2VOB_MUXER

1342 const FFOutputFormat ff_mpeg2vob_muxer = {

1343 .p.name = "vob",

1344 .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),

1345 .p.mime_type = "video/mpeg",

1346 .p.extensions = "vob",

1347 .priv_data_size = sizeof(MpegMuxContext),

1348 .p.audio_codec = AV_CODEC_ID_MP2,

1349 .p.video_codec = AV_CODEC_ID_MPEG2VIDEO,

1350 .write_header = mpeg_mux_init,

1351 .write_packet = mpeg_mux_write_packet,

1352 .write_trailer = mpeg_mux_end,

1353 .deinit = mpeg_mux_deinit,

1354 .p.priv_class = &mpeg_class,

1355 };

1356 #endif

1357

1358 /* Same as mpeg2vob_mux except that the pack size is 2324 */

1359 #if CONFIG_MPEG2SVCD_MUXER

1360 const FFOutputFormat ff_mpeg2svcd_muxer = {

1361 .p.name = "svcd",

1362 .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),

1363 .p.mime_type = "video/mpeg",

1364 .p.extensions = "vob",

1365 .priv_data_size = sizeof(MpegMuxContext),

1366 .p.audio_codec = AV_CODEC_ID_MP2,

1367 .p.video_codec = AV_CODEC_ID_MPEG2VIDEO,

1368 .write_header = mpeg_mux_init,

1369 .write_packet = mpeg_mux_write_packet,

1370 .write_trailer = mpeg_mux_end,

1371 .deinit = mpeg_mux_deinit,

1372 .p.priv_class = &mpeg_class,

1373 };

1374 #endif

1375

1376 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */

1377 #if CONFIG_MPEG2DVD_MUXER

1378 const FFOutputFormat ff_mpeg2dvd_muxer = {

1379 .p.name = "dvd",

1380 .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),

1381 .p.mime_type = "video/mpeg",

1382 .p.extensions = "dvd",

1383 .priv_data_size = sizeof(MpegMuxContext),

1384 .p.audio_codec = AV_CODEC_ID_MP2,

1385 .p.video_codec = AV_CODEC_ID_MPEG2VIDEO,

1386 .write_header = mpeg_mux_init,

1387 .write_packet = mpeg_mux_write_packet,

1388 .write_trailer = mpeg_mux_end,

1389 .deinit = mpeg_mux_deinit,

1390 .p.priv_class = &mpeg_class,

1391 };

1392 #endif

PacketDesc::pts

int64_t pts

Definition: mpegenc.c:45

StreamInfo::vobu_start_pts

int64_t vobu_start_pts

Definition: mpegenc.c:65

StreamInfo::last_packet

PacketDesc * last_packet

Definition: mpegenc.c:58

AVMEDIA_TYPE_SUBTITLE

@ AVMEDIA_TYPE_SUBTITLE

Definition: avutil.h:203

StreamInfo::lpcm_align

int lpcm_align

Definition: mpegenc.c:62

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

ff_mpeg1system_muxer

const FFOutputFormat ff_mpeg1system_muxer

av_fifo_can_write

size_t av_fifo_can_write(const AVFifo *f)

Definition: fifo.c:94

AV_CODEC_ID_AC3

@ AV_CODEC_ID_AC3

Definition: codec_id.h:462

SYSTEM_HEADER_START_CODE

#define SYSTEM_HEADER_START_CODE

Definition: mpeg.h:29

AVOutputFormat::name

const char * name

Definition: avformat.h:506

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

opt.h

StreamInfo::align_iframe

int align_iframe

Definition: mpegenc.c:64

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:51

space

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated space

Definition: undefined.txt:4

MpegMuxContext::last_scr

int64_t last_scr

Definition: mpegenc.c:84

get_system_header_size

static int get_system_header_size(AVFormatContext *ctx)

Definition: mpegenc.c:280

VCD_PADDING_BITRATE_DEN

#define VCD_PADDING_BITRATE_DEN

put_bytes_output

static int put_bytes_output(const PutBitContext *s)

Definition: put_bits.h:99

AVStream::priv_data

void * priv_data

Definition: avformat.h:769

MpegMuxContext::preload

int preload

Definition: mpegenc.c:89

int64_t

long long int64_t

Definition: coverity.c:34

init_put_bits

static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)

Initialize the PutBitContext s.

Definition: put_bits.h:62

mpeg_mux_init

static av_cold int mpeg_mux_init(AVFormatContext *ctx)

Definition: mpegenc.c:303

remove_decoded_packets

static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)

Definition: mpegenc.c:982

put_bits

static void put_bits(Jpeg2000EncoderContext *s, int val, int n)

put n times val bit

Definition: j2kenc.c:224

AVFormatContext::streams

AVStream ** streams

A list of all streams in the file.

Definition: avformat.h:1332

AVPacketSideData

This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...

Definition: packet.h:409

AVPacket::data

uint8_t * data

Definition: packet.h:588

AVOption

AVOption.

Definition: opt.h:429

flush_packet

static int flush_packet(AVFormatContext *ctx, int stream_index, int64_t pts, int64_t dts, int64_t scr, int trailer_size)

Definition: mpegenc.c:651

AUDIO_ID

#define AUDIO_ID

Definition: mpeg.h:41

put_bits32

static av_unused void put_bits32(PutBitContext *s, uint32_t value)

Write exactly 32 bits into a bitstream.

Definition: put_bits.h:301

StreamInfo::lpcm_header

uint8_t lpcm_header[3]

Definition: mpegenc.c:61

mathematics.h

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

get_nb_frames

static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len)

Definition: mpegenc.c:629

PacketDesc::next

struct PacketDesc * next

Definition: mpegenc.c:49

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:329

MpegMuxContext::system_header_freq

int system_header_freq

Definition: mpegenc.c:73

AV_CODEC_ID_TRUEHD

@ AV_CODEC_ID_TRUEHD

Definition: codec_id.h:503

StreamInfo::packet_number

int packet_number

Definition: mpegenc.c:60

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: packet.h:643

MpegMuxContext

Definition: mpegenc.c:68

FFOutputFormat::p

AVOutputFormat p

The public AVOutputFormat.

Definition: mux.h:65

avio_write_marker

void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)

Mark the written bytestream as a specific type.

Definition: aviobuf.c:464

fifo.h

avpriv_set_pts_info

void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)

Set the time base and wrapping info for a given stream.

Definition: avformat.c:777

AV_CODEC_ID_PCM_S16BE

@ AV_CODEC_ID_PCM_S16BE

Definition: codec_id.h:338

av_fifo_write

int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)

Write data into a FIFO.

Definition: fifo.c:188

MpegMuxContext::is_dvd

int is_dvd

Definition: mpegenc.c:83

output_packet

static int output_packet(AVFormatContext *ctx, int flush)

Definition: mpegenc.c:1011

av_fifo_grow2

int av_fifo_grow2(AVFifo *f, size_t inc)

Enlarge an AVFifo.

Definition: fifo.c:99

MpegMuxContext::audio_bound

int audio_bound

Definition: mpegenc.c:78

pts

static int64_t pts

Definition: transcode_aac.c:644

PacketDesc

Definition: mpegenc.c:44

AV_CODEC_ID_MP3

@ AV_CODEC_ID_MP3

preferred ID for decoding MPEG audio layer 1, 2 or 3

Definition: codec_id.h:460

StreamInfo::max_buffer_size

int max_buffer_size

Definition: mpegenc.c:55

StreamInfo::id

uint8_t id

Definition: mpegenc.c:54

get_vcd_padding_size

static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)

Definition: mpegenc.c:590

AV_LOG_TRACE

#define AV_LOG_TRACE

Extremely verbose debugging, useful for libav* development.

Definition: log.h:236

pkt

AVPacket * pkt

Definition: movenc.c:60

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

av_cold

#define av_cold

Definition: attributes.h:106

StreamInfo::predecode_packet

PacketDesc * predecode_packet

Definition: mpegenc.c:57

attributes_internal.h

#define s(width, name)

Definition: cbs_vp9.c:198

MpegMuxContext::is_mpeg2

int is_mpeg2

Definition: mpegenc.c:80

bitrate

int64_t bitrate

Definition: av1_levels.c:47

H264_ID

#define H264_ID

Definition: mpeg.h:43

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:201

AV_CODEC_ID_MP2

@ AV_CODEC_ID_MP2

Definition: codec_id.h:459

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:41

StreamInfo::fifo

AVFifo * fifo

Definition: mpegenc.c:53

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:231

AVPacketSideData::data

uint8_t * data

Definition: packet.h:410

ctx

AVFormatContext * ctx

Definition: movenc.c:49

lpcm_freq_tab

static const int lpcm_freq_tab[4]

Definition: mpeg.h:64

MpegMuxContext::mux_rate

int mux_rate

Definition: mpegenc.c:76

MpegMuxContext::user_mux_rate

int user_mux_rate

Definition: mpegenc.c:75

AV_CODEC_ID_PCM_DVD

@ AV_CODEC_ID_PCM_DVD

Definition: codec_id.h:356

AVCodecParameters::nb_coded_side_data

int nb_coded_side_data

Amount of entries in coded_side_data.

Definition: codec_par.h:86

AVCPBProperties

This structure describes the bitrate properties of an encoded bitstream.

Definition: defs.h:282

AV_CODEC_ID_H264

@ AV_CODEC_ID_H264

Definition: codec_id.h:79

PutBitContext

Definition: put_bits.h:50

MpegMuxContext::is_svcd

int is_svcd

Definition: mpegenc.c:82

ff_mpeg2svcd_muxer

const EXTERN FFOutputFormat ff_mpeg2svcd_muxer

Definition: mpegenc.c:94

tmp

static uint8_t tmp[40]

Definition: aes_ctr.c:52

PacketDesc::size

int size

Definition: mpegenc.c:47

EXTERN

#define EXTERN

Definition: attributes_internal.h:34

MpegMuxContext::pack_header_freq

int pack_header_freq

Definition: mpegenc.c:72

if(ret)

Definition: filter_design.txt:179

AVFormatContext

Format I/O context.

Definition: avformat.h:1264

internal.h

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:767

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

ff_mpeg2vob_muxer

const EXTERN FFOutputFormat ff_mpeg2vob_muxer

Definition: mpegenc.c:95

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:76

NULL

#define NULL

Definition: coverity.c:32

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

AV_WB16

#define AV_WB16(p, v)

Definition: intreadwrite.h:401

AC3_ID

#define AC3_ID

Definition: mpeg.h:44

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:241

AVFormatContext::pb

AVIOContext * pb

I/O context.

Definition: avformat.h:1306

av_fifo_can_read

size_t av_fifo_can_read(const AVFifo *f)

Definition: fifo.c:87

flush

void(* flush)(AVBSFContext *ctx)

Definition: dts2pts.c:552

options

Definition: swscale.c:43

MpegMuxContext::system_header_size

int system_header_size

Definition: mpegenc.c:74

FFOutputFormat

Definition: mux.h:61

LPCM_ID

#define LPCM_ID

Definition: mpeg.h:46

avio_w8

void avio_w8(AVIOContext *s, int b)

Definition: aviobuf.c:184

StreamInfo::bytes_to_iframe

int bytes_to_iframe

Definition: mpegenc.c:63

put_padding_packet

static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb, int packet_bytes)

Definition: mpegenc.c:613

ffio_fill

void ffio_fill(AVIOContext *s, int b, int64_t count)

Definition: aviobuf.c:192

PACK_START_CODE

#define PACK_START_CODE

Definition: mpeg.h:28

AVCodecParameters::ch_layout

AVChannelLayout ch_layout

Audio only.

Definition: codec_par.h:180

put_timestamp

static void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)

Definition: mpegenc.c:581

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: codec_par.h:184

AV_CODEC_ID_MPEG1VIDEO

@ AV_CODEC_ID_MPEG1VIDEO

Definition: codec_id.h:53

av_packet_side_data_get

const AVPacketSideData * av_packet_side_data_get(const AVPacketSideData *sd, int nb_sd, enum AVPacketSideDataType type)

Get side information from a side data array.

Definition: packet.c:644

ff_mpeg1vcd_muxer

const EXTERN FFOutputFormat ff_mpeg1vcd_muxer

Definition: mpegenc.c:92

AVFormatContext::nb_streams

unsigned int nb_streams

Number of elements in AVFormatContext.streams.

Definition: avformat.h:1320

AVIOContext

Bytestream IO Context.

Definition: avio.h:160

av_fifo_read_to_cb

int av_fifo_read_to_cb(AVFifo *f, AVFifoCB write_cb, void *opaque, size_t *nb_elems)

Feed data from a FIFO into a user-provided callback.

Definition: fifo.c:247

StreamInfo

Definition: mpegenc.c:52

AVPacket::size

int size

Definition: packet.h:589

AVFifo

Definition: fifo.c:35

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:94

PRIVATE_STREAM_1

#define PRIVATE_STREAM_1

Definition: mpeg.h:37

put_vcd_padding_sector

static void put_vcd_padding_sector(AVFormatContext *ctx)

Definition: mpegenc.c:959

AV_CODEC_ID_DTS

@ AV_CODEC_ID_DTS

Definition: codec_id.h:463

size

int size

Definition: twinvq_data.h:10344

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:247

mpeg_class

static const AVClass mpeg_class

Definition: mpegenc.c:1301

AVPacket::dts

int64_t dts

Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.

Definition: packet.h:587

avio_write

void avio_write(AVIOContext *s, const unsigned char *buf, int size)

Definition: aviobuf.c:206

avio_wb32

void avio_wb32(AVIOContext *s, unsigned int val)

Definition: aviobuf.c:368

fifo_avio_wrapper

static int fifo_avio_wrapper(void *opaque, void *buf, size_t *nb_elems)

Definition: mpegenc.c:644

mpeg.h

attributes.h

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: packet.h:594

StreamInfo::buffer_index

int buffer_index

Definition: mpegenc.c:56

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:221

avcodec_get_name

const char * avcodec_get_name(enum AVCodecID id)

Get the name of a codec.

Definition: utils.c:406

#define E

Definition: mpegenc.c:1294

PRIVATE_STREAM_2

#define PRIVATE_STREAM_2

Definition: mpeg.h:39

AV_PKT_DATA_CPB_PROPERTIES

@ AV_PKT_DATA_CPB_PROPERTIES

This side data corresponds to the AVCPBProperties struct.

Definition: packet.h:142

StreamInfo::premux_packet

PacketDesc * premux_packet

Definition: mpegenc.c:59

log.h

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: packet.h:581

avio_internal.h

mpeg_mux_end

static int mpeg_mux_end(AVFormatContext *ctx)

Definition: mpegenc.c:1252

AV_TIME_BASE

#define AV_TIME_BASE

Internal time base represented as integer.

Definition: avutil.h:253

AVCPBProperties::max_bitrate

int64_t max_bitrate

Maximum bitrate of the stream, in bits per second.

Definition: defs.h:287

AVFormatContext::max_delay

int max_delay

Definition: avformat.h:1409

DTS_ID

#define DTS_ID

Definition: mpeg.h:45

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:256

ff_mpeg2dvd_muxer

const EXTERN FFOutputFormat ff_mpeg2dvd_muxer

Definition: mpegenc.c:93

len

int len

Definition: vorbis_enc_data.h:426

PacketDesc::dts

int64_t dts

Definition: mpegenc.c:46

av_rescale

int64_t av_rescale(int64_t a, int64_t b, int64_t c)

Rescale a 64-bit integer with rounding to nearest.

Definition: mathematics.c:129

MpegMuxContext::vcd_padding_bytes_written

int64_t vcd_padding_bytes_written

Definition: mpegenc.c:87

AVCodecParameters::coded_side_data

AVPacketSideData * coded_side_data

Additional data associated with the entire stream.

Definition: codec_par.h:81

MpegMuxContext::is_vcd

int is_vcd

Definition: mpegenc.c:81

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:744

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:81

AVFormatContext::oformat

const struct AVOutputFormat * oformat

The output container format.

Definition: avformat.h:1283

AVCPBProperties::buffer_size

int64_t buffer_size

The size of the buffer to which the ratecontrol is applied, in bits.

Definition: defs.h:303

avformat.h

av_fifo_alloc2

AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)

Allocate and initialize an AVFifo with a given element size.

Definition: fifo.c:47

enum AVCodecID id

Definition: dts2pts.c:549

VIDEO_ID

#define VIDEO_ID

Definition: mpeg.h:42

av_get_media_type_string

const char * av_get_media_type_string(enum AVMediaType media_type)

Return a string describing the media_type enum, NULL if media_type is unknown.

Definition: utils.c:28

MpegMuxContext::video_bound

int video_bound

Definition: mpegenc.c:79

PADDING_STREAM

#define PADDING_STREAM

Definition: mpeg.h:38

buffer

the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer

Definition: filter_design.txt:49

OFFSET

#define OFFSET(x)

Definition: mpegenc.c:1293

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Underlying C type is int.

Definition: opt.h:259

SUB_ID

#define SUB_ID

Definition: mpeg.h:47

Windows::Graphics::DirectX::Direct3D11::p