1/* 2 * MPEG1/2 muxer 3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard 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#include "libavutil/fifo.h" 23#include "libavcodec/put_bits.h" 24#include "avformat.h" 25#include "mpeg.h" 26 27#define MAX_PAYLOAD_SIZE 4096 28//#define DEBUG_SEEK 29 30#undef NDEBUG 31#include <assert.h> 32 33typedef struct PacketDesc { 34 int64_t pts; 35 int64_t dts; 36 int size; 37 int unwritten_size; 38 int flags; 39 struct PacketDesc *next; 40} PacketDesc; 41 42typedef struct { 43 AVFifoBuffer *fifo; 44 uint8_t id; 45 int max_buffer_size; /* in bytes */ 46 int buffer_index; 47 PacketDesc *predecode_packet; 48 PacketDesc *premux_packet; 49 PacketDesc **next_packet; 50 int packet_number; 51 uint8_t lpcm_header[3]; 52 int lpcm_align; 53 int bytes_to_iframe; 54 int align_iframe; 55 int64_t vobu_start_pts; 56} StreamInfo; 57 58typedef struct { 59 int packet_size; /* required packet size */ 60 int packet_number; 61 int pack_header_freq; /* frequency (in packets^-1) at which we send pack headers */ 62 int system_header_freq; 63 int system_header_size; 64 int mux_rate; /* bitrate in units of 50 bytes/s */ 65 /* stream info */ 66 int audio_bound; 67 int video_bound; 68 int is_mpeg2; 69 int is_vcd; 70 int is_svcd; 71 int is_dvd; 72 int64_t last_scr; /* current system clock */ 73 74 double vcd_padding_bitrate; //FIXME floats 75 int64_t vcd_padding_bytes_written; 76 77} MpegMuxContext; 78 79extern AVOutputFormat mpeg1vcd_muxer; 80extern AVOutputFormat mpeg2dvd_muxer; 81extern AVOutputFormat mpeg2svcd_muxer; 82extern AVOutputFormat mpeg2vob_muxer; 83 84static int put_pack_header(AVFormatContext *ctx, 85 uint8_t *buf, int64_t timestamp) 86{ 87 MpegMuxContext *s = ctx->priv_data; 88 PutBitContext pb; 89 90 init_put_bits(&pb, buf, 128); 91 92 put_bits32(&pb, PACK_START_CODE); 93 if (s->is_mpeg2) { 94 put_bits(&pb, 2, 0x1); 95 } else { 96 put_bits(&pb, 4, 0x2); 97 } 98 put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07)); 99 put_bits(&pb, 1, 1); 100 put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff)); 101 put_bits(&pb, 1, 1); 102 put_bits(&pb, 15, (uint32_t)((timestamp ) & 0x7fff)); 103 put_bits(&pb, 1, 1); 104 if (s->is_mpeg2) { 105 /* clock extension */ 106 put_bits(&pb, 9, 0); 107 } 108 put_bits(&pb, 1, 1); 109 put_bits(&pb, 22, s->mux_rate); 110 put_bits(&pb, 1, 1); 111 if (s->is_mpeg2) { 112 put_bits(&pb, 1, 1); 113 put_bits(&pb, 5, 0x1f); /* reserved */ 114 put_bits(&pb, 3, 0); /* stuffing length */ 115 } 116 flush_put_bits(&pb); 117 return put_bits_ptr(&pb) - pb.buf; 118} 119 120static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id) 121{ 122 MpegMuxContext *s = ctx->priv_data; 123 int size, i, private_stream_coded, id; 124 PutBitContext pb; 125 126 init_put_bits(&pb, buf, 128); 127 128 put_bits32(&pb, SYSTEM_HEADER_START_CODE); 129 put_bits(&pb, 16, 0); 130 put_bits(&pb, 1, 1); 131 132 put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */ 133 put_bits(&pb, 1, 1); /* marker */ 134 if (s->is_vcd && only_for_stream_id==VIDEO_ID) { 135 /* This header applies only to the video stream (see VCD standard p. IV-7)*/ 136 put_bits(&pb, 6, 0); 137 } else 138 put_bits(&pb, 6, s->audio_bound); 139 140 if (s->is_vcd) { 141 /* see VCD standard, p. IV-7*/ 142 put_bits(&pb, 1, 0); 143 put_bits(&pb, 1, 1); 144 } else { 145 put_bits(&pb, 1, 0); /* variable bitrate*/ 146 put_bits(&pb, 1, 0); /* non constrainted bit stream */ 147 } 148 149 if (s->is_vcd || s->is_dvd) { 150 /* see VCD standard p IV-7 */ 151 put_bits(&pb, 1, 1); /* audio locked */ 152 put_bits(&pb, 1, 1); /* video locked */ 153 } else { 154 put_bits(&pb, 1, 0); /* audio locked */ 155 put_bits(&pb, 1, 0); /* video locked */ 156 } 157 158 put_bits(&pb, 1, 1); /* marker */ 159 160 if (s->is_vcd && (only_for_stream_id & 0xe0) == AUDIO_ID) { 161 /* This header applies only to the audio stream (see VCD standard p. IV-7)*/ 162 put_bits(&pb, 5, 0); 163 } else 164 put_bits(&pb, 5, s->video_bound); 165 166 if (s->is_dvd) { 167 put_bits(&pb, 1, 0); /* packet_rate_restriction_flag */ 168 put_bits(&pb, 7, 0x7f); /* reserved byte */ 169 } else 170 put_bits(&pb, 8, 0xff); /* reserved byte */ 171 172 /* DVD-Video Stream_bound entries 173 id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1) 174 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) 175 id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1) 176 id (0xBF) private stream 2, NAV packs, set to 2x1024. */ 177 if (s->is_dvd) { 178 179 int P_STD_max_video = 0; 180 int P_STD_max_mpeg_audio = 0; 181 int P_STD_max_mpeg_PS1 = 0; 182 183 for(i=0;i<ctx->nb_streams;i++) { 184 StreamInfo *stream = ctx->streams[i]->priv_data; 185 186 id = stream->id; 187 if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) { 188 P_STD_max_mpeg_PS1 = stream->max_buffer_size; 189 } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) { 190 P_STD_max_mpeg_audio = stream->max_buffer_size; 191 } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) { 192 P_STD_max_video = stream->max_buffer_size; 193 } 194 } 195 196 /* video */ 197 put_bits(&pb, 8, 0xb9); /* stream ID */ 198 put_bits(&pb, 2, 3); 199 put_bits(&pb, 1, 1); 200 put_bits(&pb, 13, P_STD_max_video / 1024); 201 202 /* audio */ 203 if (P_STD_max_mpeg_audio == 0) 204 P_STD_max_mpeg_audio = 4096; 205 put_bits(&pb, 8, 0xb8); /* stream ID */ 206 put_bits(&pb, 2, 3); 207 put_bits(&pb, 1, 0); 208 put_bits(&pb, 13, P_STD_max_mpeg_audio / 128); 209 210 /* private stream 1 */ 211 put_bits(&pb, 8, 0xbd); /* stream ID */ 212 put_bits(&pb, 2, 3); 213 put_bits(&pb, 1, 0); 214 put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128); 215 216 /* private stream 2 */ 217 put_bits(&pb, 8, 0xbf); /* stream ID */ 218 put_bits(&pb, 2, 3); 219 put_bits(&pb, 1, 1); 220 put_bits(&pb, 13, 2); 221 } 222 else { 223 /* audio stream info */ 224 private_stream_coded = 0; 225 for(i=0;i<ctx->nb_streams;i++) { 226 StreamInfo *stream = ctx->streams[i]->priv_data; 227 228 229 /* For VCDs, only include the stream info for the stream 230 that the pack which contains this system belongs to. 231 (see VCD standard p. IV-7) */ 232 if ( !s->is_vcd || stream->id==only_for_stream_id 233 || only_for_stream_id==0) { 234 235 id = stream->id; 236 if (id < 0xc0) { 237 /* special case for private streams (AC-3 uses that) */ 238 if (private_stream_coded) 239 continue; 240 private_stream_coded = 1; 241 id = 0xbd; 242 } 243 put_bits(&pb, 8, id); /* stream ID */ 244 put_bits(&pb, 2, 3); 245 if (id < 0xe0) { 246 /* audio */ 247 put_bits(&pb, 1, 0); 248 put_bits(&pb, 13, stream->max_buffer_size / 128); 249 } else { 250 /* video */ 251 put_bits(&pb, 1, 1); 252 put_bits(&pb, 13, stream->max_buffer_size / 1024); 253 } 254 } 255 } 256 } 257 258 flush_put_bits(&pb); 259 size = put_bits_ptr(&pb) - pb.buf; 260 /* patch packet size */ 261 buf[4] = (size - 6) >> 8; 262 buf[5] = (size - 6) & 0xff; 263 264 return size; 265} 266 267static int get_system_header_size(AVFormatContext *ctx) 268{ 269 int buf_index, i, private_stream_coded; 270 StreamInfo *stream; 271 MpegMuxContext *s = ctx->priv_data; 272 273 if (s->is_dvd) 274 return 18; // DVD-Video system headers are 18 bytes fixed length. 275 276 buf_index = 12; 277 private_stream_coded = 0; 278 for(i=0;i<ctx->nb_streams;i++) { 279 stream = ctx->streams[i]->priv_data; 280 if (stream->id < 0xc0) { 281 if (private_stream_coded) 282 continue; 283 private_stream_coded = 1; 284 } 285 buf_index += 3; 286 } 287 return buf_index; 288} 289 290static int mpeg_mux_init(AVFormatContext *ctx) 291{ 292 MpegMuxContext *s = ctx->priv_data; 293 int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j; 294 AVStream *st; 295 StreamInfo *stream; 296 int audio_bitrate; 297 int video_bitrate; 298 299 s->packet_number = 0; 300 s->is_vcd = (CONFIG_MPEG1VCD_MUXER && ctx->oformat == &mpeg1vcd_muxer); 301 s->is_svcd = (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &mpeg2svcd_muxer); 302 s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER && ctx->oformat == &mpeg2vob_muxer) || 303 (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &mpeg2dvd_muxer) || 304 (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &mpeg2svcd_muxer)); 305 s->is_dvd = (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &mpeg2dvd_muxer); 306 307 if(ctx->packet_size) { 308 if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) { 309 av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n", 310 ctx->packet_size); 311 goto fail; 312 } 313 s->packet_size = ctx->packet_size; 314 } else 315 s->packet_size = 2048; 316 317 s->vcd_padding_bytes_written = 0; 318 s->vcd_padding_bitrate=0; 319 320 s->audio_bound = 0; 321 s->video_bound = 0; 322 mpa_id = AUDIO_ID; 323 ac3_id = AC3_ID; 324 dts_id = DTS_ID; 325 mpv_id = VIDEO_ID; 326 mps_id = SUB_ID; 327 lpcm_id = LPCM_ID; 328 for(i=0;i<ctx->nb_streams;i++) { 329 st = ctx->streams[i]; 330 stream = av_mallocz(sizeof(StreamInfo)); 331 if (!stream) 332 goto fail; 333 st->priv_data = stream; 334 335 av_set_pts_info(st, 64, 1, 90000); 336 337 switch(st->codec->codec_type) { 338 case AVMEDIA_TYPE_AUDIO: 339 if (st->codec->codec_id == CODEC_ID_AC3) { 340 stream->id = ac3_id++; 341 } else if (st->codec->codec_id == CODEC_ID_DTS) { 342 stream->id = dts_id++; 343 } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) { 344 stream->id = lpcm_id++; 345 for(j = 0; j < 4; j++) { 346 if (lpcm_freq_tab[j] == st->codec->sample_rate) 347 break; 348 } 349 if (j == 4) 350 goto fail; 351 if (st->codec->channels > 8) 352 return -1; 353 stream->lpcm_header[0] = 0x0c; 354 stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4); 355 stream->lpcm_header[2] = 0x80; 356 stream->lpcm_align = st->codec->channels * 2; 357 } else { 358 stream->id = mpa_id++; 359 } 360 361 /* This value HAS to be used for VCD (see VCD standard, p. IV-7). 362 Right now it is also used for everything else.*/ 363 stream->max_buffer_size = 4 * 1024; 364 s->audio_bound++; 365 break; 366 case AVMEDIA_TYPE_VIDEO: 367 stream->id = mpv_id++; 368 if (st->codec->rc_buffer_size) 369 stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8; 370 else 371 stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default 372#if 0 373 /* see VCD standard, p. IV-7*/ 374 stream->max_buffer_size = 46 * 1024; 375 else 376 /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2). 377 Right now it is also used for everything else.*/ 378 stream->max_buffer_size = 230 * 1024; 379#endif 380 s->video_bound++; 381 break; 382 case AVMEDIA_TYPE_SUBTITLE: 383 stream->id = mps_id++; 384 stream->max_buffer_size = 16 * 1024; 385 break; 386 default: 387 return -1; 388 } 389 stream->fifo= av_fifo_alloc(16); 390 if (!stream->fifo) 391 goto fail; 392 } 393 bitrate = 0; 394 audio_bitrate = 0; 395 video_bitrate = 0; 396 for(i=0;i<ctx->nb_streams;i++) { 397 int codec_rate; 398 st = ctx->streams[i]; 399 stream = (StreamInfo*) st->priv_data; 400 401 if(st->codec->rc_max_rate || stream->id==VIDEO_ID) 402 codec_rate= st->codec->rc_max_rate; 403 else 404 codec_rate= st->codec->bit_rate; 405 406 if(!codec_rate) 407 codec_rate= (1<<21)*8*50/ctx->nb_streams; 408 409 bitrate += codec_rate; 410 411 if ((stream->id & 0xe0) == AUDIO_ID) 412 audio_bitrate += codec_rate; 413 else if (stream->id==VIDEO_ID) 414 video_bitrate += codec_rate; 415 } 416 417 if(ctx->mux_rate){ 418 s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50); 419 } else { 420 /* we increase slightly the bitrate to take into account the 421 headers. XXX: compute it exactly */ 422 bitrate += bitrate*5/100; 423 bitrate += 10000; 424 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50); 425 } 426 427 if (s->is_vcd) { 428 double overhead_rate; 429 430 /* The VCD standard mandates that the mux_rate field is 3528 431 (see standard p. IV-6). 432 The value is actually "wrong", i.e. if you calculate 433 it using the normal formula and the 75 sectors per second transfer 434 rate you get a different value because the real pack size is 2324, 435 not 2352. But the standard explicitly specifies that the mux_rate 436 field in the header must have this value.*/ 437// s->mux_rate=2352 * 75 / 50; /* = 3528*/ 438 439 /* The VCD standard states that the muxed stream must be 440 exactly 75 packs / second (the data rate of a single speed cdrom). 441 Since the video bitrate (probably 1150000 bits/sec) will be below 442 the theoretical maximum we have to add some padding packets 443 to make up for the lower data rate. 444 (cf. VCD standard p. IV-6 )*/ 445 446 /* Add the header overhead to the data rate. 447 2279 data bytes per audio pack, 2294 data bytes per video pack*/ 448 overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279); 449 overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294); 450 overhead_rate *= 8; 451 452 /* Add padding so that the full bitrate is 2324*75 bytes/sec */ 453 s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate); 454 } 455 456 if (s->is_vcd || s->is_mpeg2) 457 /* every packet */ 458 s->pack_header_freq = 1; 459 else 460 /* every 2 seconds */ 461 s->pack_header_freq = 2 * bitrate / s->packet_size / 8; 462 463 /* the above seems to make pack_header_freq zero sometimes */ 464 if (s->pack_header_freq == 0) 465 s->pack_header_freq = 1; 466 467 if (s->is_mpeg2) 468 /* every 200 packets. Need to look at the spec. */ 469 s->system_header_freq = s->pack_header_freq * 40; 470 else if (s->is_vcd) 471 /* the standard mandates that there are only two system headers 472 in the whole file: one in the first packet of each stream. 473 (see standard p. IV-7 and IV-8) */ 474 s->system_header_freq = 0x7fffffff; 475 else 476 s->system_header_freq = s->pack_header_freq * 5; 477 478 for(i=0;i<ctx->nb_streams;i++) { 479 stream = ctx->streams[i]->priv_data; 480 stream->packet_number = 0; 481 } 482 s->system_header_size = get_system_header_size(ctx); 483 s->last_scr = 0; 484 return 0; 485 fail: 486 for(i=0;i<ctx->nb_streams;i++) { 487 av_free(ctx->streams[i]->priv_data); 488 } 489 return AVERROR(ENOMEM); 490} 491 492static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp) 493{ 494 put_byte(pb, 495 (id << 4) | 496 (((timestamp >> 30) & 0x07) << 1) | 497 1); 498 put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1)); 499 put_be16(pb, (uint16_t)((((timestamp ) & 0x7fff) << 1) | 1)); 500} 501 502 503/* return the number of padding bytes that should be inserted into 504 the multiplexed stream.*/ 505static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts) 506{ 507 MpegMuxContext *s = ctx->priv_data; 508 int pad_bytes = 0; 509 510 if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE) 511 { 512 int64_t full_pad_bytes; 513 514 full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong 515 pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written); 516 517 if (pad_bytes<0) 518 /* might happen if we have already padded to a later timestamp. This 519 can occur if another stream has already advanced further.*/ 520 pad_bytes=0; 521 } 522 523 return pad_bytes; 524} 525 526 527#if 0 /* unused, remove? */ 528/* return the exact available payload size for the next packet for 529 stream 'stream_index'. 'pts' and 'dts' are only used to know if 530 timestamps are needed in the packet header. */ 531static int get_packet_payload_size(AVFormatContext *ctx, int stream_index, 532 int64_t pts, int64_t dts) 533{ 534 MpegMuxContext *s = ctx->priv_data; 535 int buf_index; 536 StreamInfo *stream; 537 538 stream = ctx->streams[stream_index]->priv_data; 539 540 buf_index = 0; 541 if (((s->packet_number % s->pack_header_freq) == 0)) { 542 /* pack header size */ 543 if (s->is_mpeg2) 544 buf_index += 14; 545 else 546 buf_index += 12; 547 548 if (s->is_vcd) { 549 /* there is exactly one system header for each stream in a VCD MPEG, 550 One in the very first video packet and one in the very first 551 audio packet (see VCD standard p. IV-7 and IV-8).*/ 552 553 if (stream->packet_number==0) 554 /* The system headers refer only to the stream they occur in, 555 so they have a constant size.*/ 556 buf_index += 15; 557 558 } else { 559 if ((s->packet_number % s->system_header_freq) == 0) 560 buf_index += s->system_header_size; 561 } 562 } 563 564 if ((s->is_vcd && stream->packet_number==0) 565 || (s->is_svcd && s->packet_number==0)) 566 /* the first pack of each stream contains only the pack header, 567 the system header and some padding (see VCD standard p. IV-6) 568 Add the padding size, so that the actual payload becomes 0.*/ 569 buf_index += s->packet_size - buf_index; 570 else { 571 /* packet header size */ 572 buf_index += 6; 573 if (s->is_mpeg2) { 574 buf_index += 3; 575 if (stream->packet_number==0) 576 buf_index += 3; /* PES extension */ 577 buf_index += 1; /* obligatory stuffing byte */ 578 } 579 if (pts != AV_NOPTS_VALUE) { 580 if (dts != pts) 581 buf_index += 5 + 5; 582 else 583 buf_index += 5; 584 585 } else { 586 if (!s->is_mpeg2) 587 buf_index++; 588 } 589 590 if (stream->id < 0xc0) { 591 /* AC-3/LPCM private data header */ 592 buf_index += 4; 593 if (stream->id >= 0xa0) { 594 int n; 595 buf_index += 3; 596 /* NOTE: we round the payload size to an integer number of 597 LPCM samples */ 598 n = (s->packet_size - buf_index) % stream->lpcm_align; 599 if (n) 600 buf_index += (stream->lpcm_align - n); 601 } 602 } 603 604 if (s->is_vcd && (stream->id & 0xe0) == AUDIO_ID) 605 /* The VCD standard demands that 20 zero bytes follow 606 each audio packet (see standard p. IV-8).*/ 607 buf_index+=20; 608 } 609 return s->packet_size - buf_index; 610} 611#endif 612 613/* Write an MPEG padding packet header. */ 614static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes) 615{ 616 MpegMuxContext *s = ctx->priv_data; 617 int i; 618 619 put_be32(pb, PADDING_STREAM); 620 put_be16(pb, packet_bytes - 6); 621 if (!s->is_mpeg2) { 622 put_byte(pb, 0x0f); 623 packet_bytes -= 7; 624 } else 625 packet_bytes -= 6; 626 627 for(i=0;i<packet_bytes;i++) 628 put_byte(pb, 0xff); 629} 630 631static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){ 632 int nb_frames=0; 633 PacketDesc *pkt_desc= stream->premux_packet; 634 635 while(len>0){ 636 if(pkt_desc->size == pkt_desc->unwritten_size) 637 nb_frames++; 638 len -= pkt_desc->unwritten_size; 639 pkt_desc= pkt_desc->next; 640 } 641 642 return nb_frames; 643} 644 645/* flush the packet on stream stream_index */ 646static int flush_packet(AVFormatContext *ctx, int stream_index, 647 int64_t pts, int64_t dts, int64_t scr, int trailer_size) 648{ 649 MpegMuxContext *s = ctx->priv_data; 650 StreamInfo *stream = ctx->streams[stream_index]->priv_data; 651 uint8_t *buf_ptr; 652 int size, payload_size, startcode, id, stuffing_size, i, header_len; 653 int packet_size; 654 uint8_t buffer[128]; 655 int zero_trail_bytes = 0; 656 int pad_packet_bytes = 0; 657 int pes_flags; 658 int general_pack = 0; /*"general" pack without data specific to one stream?*/ 659 int nb_frames; 660 661 id = stream->id; 662 663#if 0 664 printf("packet ID=%2x PTS=%0.3f\n", 665 id, pts / 90000.0); 666#endif 667 668 buf_ptr = buffer; 669 670 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) { 671 /* output pack and systems header if needed */ 672 size = put_pack_header(ctx, buf_ptr, scr); 673 buf_ptr += size; 674 s->last_scr= scr; 675 676 if (s->is_vcd) { 677 /* there is exactly one system header for each stream in a VCD MPEG, 678 One in the very first video packet and one in the very first 679 audio packet (see VCD standard p. IV-7 and IV-8).*/ 680 681 if (stream->packet_number==0) { 682 size = put_system_header(ctx, buf_ptr, id); 683 buf_ptr += size; 684 } 685 } else if (s->is_dvd) { 686 if (stream->align_iframe || s->packet_number == 0){ 687 int PES_bytes_to_fill = s->packet_size - size - 10; 688 689 if (pts != AV_NOPTS_VALUE) { 690 if (dts != pts) 691 PES_bytes_to_fill -= 5 + 5; 692 else 693 PES_bytes_to_fill -= 5; 694 } 695 696 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) { 697 size = put_system_header(ctx, buf_ptr, 0); 698 buf_ptr += size; 699 size = buf_ptr - buffer; 700 put_buffer(ctx->pb, buffer, size); 701 702 put_be32(ctx->pb, PRIVATE_STREAM_2); 703 put_be16(ctx->pb, 0x03d4); // length 704 put_byte(ctx->pb, 0x00); // substream ID, 00=PCI 705 for (i = 0; i < 979; i++) 706 put_byte(ctx->pb, 0x00); 707 708 put_be32(ctx->pb, PRIVATE_STREAM_2); 709 put_be16(ctx->pb, 0x03fa); // length 710 put_byte(ctx->pb, 0x01); // substream ID, 01=DSI 711 for (i = 0; i < 1017; i++) 712 put_byte(ctx->pb, 0x00); 713 714 memset(buffer, 0, 128); 715 buf_ptr = buffer; 716 s->packet_number++; 717 stream->align_iframe = 0; 718 scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet 719 size = put_pack_header(ctx, buf_ptr, scr); 720 s->last_scr= scr; 721 buf_ptr += size; 722 /* GOP Start */ 723 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) { 724 pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe; 725 } 726 } 727 } else { 728 if ((s->packet_number % s->system_header_freq) == 0) { 729 size = put_system_header(ctx, buf_ptr, 0); 730 buf_ptr += size; 731 } 732 } 733 } 734 size = buf_ptr - buffer; 735 put_buffer(ctx->pb, buffer, size); 736 737 packet_size = s->packet_size - size; 738 739 if (s->is_vcd && (id & 0xe0) == AUDIO_ID) 740 /* The VCD standard demands that 20 zero bytes follow 741 each audio pack (see standard p. IV-8).*/ 742 zero_trail_bytes += 20; 743 744 if ((s->is_vcd && stream->packet_number==0) 745 || (s->is_svcd && s->packet_number==0)) { 746 /* for VCD the first pack of each stream contains only the pack header, 747 the system header and lots of padding (see VCD standard p. IV-6). 748 In the case of an audio pack, 20 zero bytes are also added at 749 the end.*/ 750 /* For SVCD we fill the very first pack to increase compatibility with 751 some DVD players. Not mandated by the standard.*/ 752 if (s->is_svcd) 753 general_pack = 1; /* the system header refers to both streams and no stream data*/ 754 pad_packet_bytes = packet_size - zero_trail_bytes; 755 } 756 757 packet_size -= pad_packet_bytes + zero_trail_bytes; 758 759 if (packet_size > 0) { 760 761 /* packet header size */ 762 packet_size -= 6; 763 764 /* packet header */ 765 if (s->is_mpeg2) { 766 header_len = 3; 767 if (stream->packet_number==0) 768 header_len += 3; /* PES extension */ 769 header_len += 1; /* obligatory stuffing byte */ 770 } else { 771 header_len = 0; 772 } 773 if (pts != AV_NOPTS_VALUE) { 774 if (dts != pts) 775 header_len += 5 + 5; 776 else 777 header_len += 5; 778 } else { 779 if (!s->is_mpeg2) 780 header_len++; 781 } 782 783 payload_size = packet_size - header_len; 784 if (id < 0xc0) { 785 startcode = PRIVATE_STREAM_1; 786 payload_size -= 1; 787 if (id >= 0x40) { 788 payload_size -= 3; 789 if (id >= 0xa0) 790 payload_size -= 3; 791 } 792 } else { 793 startcode = 0x100 + id; 794 } 795 796 stuffing_size = payload_size - av_fifo_size(stream->fifo); 797 798 // first byte does not fit -> reset pts/dts + stuffing 799 if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){ 800 int timestamp_len=0; 801 if(dts != pts) 802 timestamp_len += 5; 803 if(pts != AV_NOPTS_VALUE) 804 timestamp_len += s->is_mpeg2 ? 5 : 4; 805 pts=dts= AV_NOPTS_VALUE; 806 header_len -= timestamp_len; 807 if (s->is_dvd && stream->align_iframe) { 808 pad_packet_bytes += timestamp_len; 809 packet_size -= timestamp_len; 810 } else { 811 payload_size += timestamp_len; 812 } 813 stuffing_size += timestamp_len; 814 if(payload_size > trailer_size) 815 stuffing_size += payload_size - trailer_size; 816 } 817 818 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing 819 packet_size += pad_packet_bytes; 820 payload_size += pad_packet_bytes; // undo the previous adjustment 821 if (stuffing_size < 0) { 822 stuffing_size = pad_packet_bytes; 823 } else { 824 stuffing_size += pad_packet_bytes; 825 } 826 pad_packet_bytes = 0; 827 } 828 829 if (stuffing_size < 0) 830 stuffing_size = 0; 831 if (stuffing_size > 16) { /*<=16 for MPEG-1, <=32 for MPEG-2*/ 832 pad_packet_bytes += stuffing_size; 833 packet_size -= stuffing_size; 834 payload_size -= stuffing_size; 835 stuffing_size = 0; 836 } 837 838 nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size); 839 840 put_be32(ctx->pb, startcode); 841 842 put_be16(ctx->pb, packet_size); 843 844 if (!s->is_mpeg2) 845 for(i=0;i<stuffing_size;i++) 846 put_byte(ctx->pb, 0xff); 847 848 if (s->is_mpeg2) { 849 put_byte(ctx->pb, 0x80); /* mpeg2 id */ 850 851 pes_flags=0; 852 853 if (pts != AV_NOPTS_VALUE) { 854 pes_flags |= 0x80; 855 if (dts != pts) 856 pes_flags |= 0x40; 857 } 858 859 /* Both the MPEG-2 and the SVCD standards demand that the 860 P-STD_buffer_size field be included in the first packet of 861 every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2 862 and MPEG-2 standard 2.7.7) */ 863 if (stream->packet_number == 0) 864 pes_flags |= 0x01; 865 866 put_byte(ctx->pb, pes_flags); /* flags */ 867 put_byte(ctx->pb, header_len - 3 + stuffing_size); 868 869 if (pes_flags & 0x80) /*write pts*/ 870 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts); 871 if (pes_flags & 0x40) /*write dts*/ 872 put_timestamp(ctx->pb, 0x01, dts); 873 874 if (pes_flags & 0x01) { /*write pes extension*/ 875 put_byte(ctx->pb, 0x10); /* flags */ 876 877 /* P-STD buffer info */ 878 if ((id & 0xe0) == AUDIO_ID) 879 put_be16(ctx->pb, 0x4000 | stream->max_buffer_size/ 128); 880 else 881 put_be16(ctx->pb, 0x6000 | stream->max_buffer_size/1024); 882 } 883 884 } else { 885 if (pts != AV_NOPTS_VALUE) { 886 if (dts != pts) { 887 put_timestamp(ctx->pb, 0x03, pts); 888 put_timestamp(ctx->pb, 0x01, dts); 889 } else { 890 put_timestamp(ctx->pb, 0x02, pts); 891 } 892 } else { 893 put_byte(ctx->pb, 0x0f); 894 } 895 } 896 897 if (s->is_mpeg2) { 898 /* special stuffing byte that is always written 899 to prevent accidental generation of start codes. */ 900 put_byte(ctx->pb, 0xff); 901 902 for(i=0;i<stuffing_size;i++) 903 put_byte(ctx->pb, 0xff); 904 } 905 906 if (startcode == PRIVATE_STREAM_1) { 907 put_byte(ctx->pb, id); 908 if (id >= 0xa0) { 909 /* LPCM (XXX: check nb_frames) */ 910 put_byte(ctx->pb, 7); 911 put_be16(ctx->pb, 4); /* skip 3 header bytes */ 912 put_byte(ctx->pb, stream->lpcm_header[0]); 913 put_byte(ctx->pb, stream->lpcm_header[1]); 914 put_byte(ctx->pb, stream->lpcm_header[2]); 915 } else if (id >= 0x40) { 916 /* AC-3 */ 917 put_byte(ctx->pb, nb_frames); 918 put_be16(ctx->pb, trailer_size+1); 919 } 920 } 921 922 /* output data */ 923 assert(payload_size - stuffing_size <= av_fifo_size(stream->fifo)); 924 av_fifo_generic_read(stream->fifo, ctx->pb, payload_size - stuffing_size, &put_buffer); 925 stream->bytes_to_iframe -= payload_size - stuffing_size; 926 }else{ 927 payload_size= 928 stuffing_size= 0; 929 } 930 931 if (pad_packet_bytes > 0) 932 put_padding_packet(ctx,ctx->pb, pad_packet_bytes); 933 934 for(i=0;i<zero_trail_bytes;i++) 935 put_byte(ctx->pb, 0x00); 936 937 put_flush_packet(ctx->pb); 938 939 s->packet_number++; 940 941 /* only increase the stream packet number if this pack actually contains 942 something that is specific to this stream! I.e. a dedicated header 943 or some data.*/ 944 if (!general_pack) 945 stream->packet_number++; 946 947 return payload_size - stuffing_size; 948} 949 950static void put_vcd_padding_sector(AVFormatContext *ctx) 951{ 952 /* There are two ways to do this padding: writing a sector/pack 953 of 0 values, or writing an MPEG padding pack. Both seem to 954 work with most decoders, BUT the VCD standard only allows a 0-sector 955 (see standard p. IV-4, IV-5). 956 So a 0-sector it is...*/ 957 958 MpegMuxContext *s = ctx->priv_data; 959 int i; 960 961 for(i=0;i<s->packet_size;i++) 962 put_byte(ctx->pb, 0); 963 964 s->vcd_padding_bytes_written += s->packet_size; 965 966 put_flush_packet(ctx->pb); 967 968 /* increasing the packet number is correct. The SCR of the following packs 969 is calculated from the packet_number and it has to include the padding 970 sector (it represents the sector index, not the MPEG pack index) 971 (see VCD standard p. IV-6)*/ 972 s->packet_number++; 973} 974 975#if 0 /* unused, remove? */ 976static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts) 977{ 978 MpegMuxContext *s = ctx->priv_data; 979 int64_t scr; 980 981 /* Since the data delivery rate is constant, SCR is computed 982 using the formula C + i * 1200 where C is the start constant 983 and i is the pack index. 984 It is recommended that SCR 0 is at the beginning of the VCD front 985 margin (a sequence of empty Form 2 sectors on the CD). 986 It is recommended that the front margin is 30 sectors long, so 987 we use C = 30*1200 = 36000 988 (Note that even if the front margin is not 30 sectors the file 989 will still be correct according to the standard. It just won't have 990 the "recommended" value).*/ 991 scr = 36000 + s->packet_number * 1200; 992 993 return scr; 994} 995#endif 996 997static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){ 998// MpegMuxContext *s = ctx->priv_data; 999 int i; 1000 1001 for(i=0; i<ctx->nb_streams; i++){ 1002 AVStream *st = ctx->streams[i]; 1003 StreamInfo *stream = st->priv_data; 1004 PacketDesc *pkt_desc; 1005 1006 while((pkt_desc= stream->predecode_packet) 1007 && scr > pkt_desc->dts){ //FIXME > vs >= 1008 if(stream->buffer_index < pkt_desc->size || 1009 stream->predecode_packet == stream->premux_packet){ 1010 av_log(ctx, AV_LOG_ERROR, 1011 "buffer underflow i=%d bufi=%d size=%d\n", 1012 i, stream->buffer_index, pkt_desc->size); 1013 break; 1014 } 1015 stream->buffer_index -= pkt_desc->size; 1016 1017 stream->predecode_packet= pkt_desc->next; 1018 av_freep(&pkt_desc); 1019 } 1020 } 1021 1022 return 0; 1023} 1024 1025static int output_packet(AVFormatContext *ctx, int flush){ 1026 MpegMuxContext *s = ctx->priv_data; 1027 AVStream *st; 1028 StreamInfo *stream; 1029 int i, avail_space=0, es_size, trailer_size; 1030 int best_i= -1; 1031 int best_score= INT_MIN; 1032 int ignore_constraints=0; 1033 int64_t scr= s->last_scr; 1034 PacketDesc *timestamp_packet; 1035 const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE); 1036 1037retry: 1038 for(i=0; i<ctx->nb_streams; i++){ 1039 AVStream *st = ctx->streams[i]; 1040 StreamInfo *stream = st->priv_data; 1041 const int avail_data= av_fifo_size(stream->fifo); 1042 const int space= stream->max_buffer_size - stream->buffer_index; 1043 int rel_space= 1024*space / stream->max_buffer_size; 1044 PacketDesc *next_pkt= stream->premux_packet; 1045 1046 /* for subtitle, a single PES packet must be generated, 1047 so we flush after every single subtitle packet */ 1048 if(s->packet_size > avail_data && !flush 1049 && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) 1050 return 0; 1051 if(avail_data==0) 1052 continue; 1053 assert(avail_data>0); 1054 1055 if(space < s->packet_size && !ignore_constraints) 1056 continue; 1057 1058 if(next_pkt && next_pkt->dts - scr > max_delay) 1059 continue; 1060 1061 if(rel_space > best_score){ 1062 best_score= rel_space; 1063 best_i = i; 1064 avail_space= space; 1065 } 1066 } 1067 1068 if(best_i < 0){ 1069 int64_t best_dts= INT64_MAX; 1070 1071 for(i=0; i<ctx->nb_streams; i++){ 1072 AVStream *st = ctx->streams[i]; 1073 StreamInfo *stream = st->priv_data; 1074 PacketDesc *pkt_desc= stream->predecode_packet; 1075 if(pkt_desc && pkt_desc->dts < best_dts) 1076 best_dts= pkt_desc->dts; 1077 } 1078 1079#if 0 1080 av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n", 1081 scr/90000.0, best_dts/90000.0); 1082#endif 1083 if(best_dts == INT64_MAX) 1084 return 0; 1085 1086 if(scr >= best_dts+1 && !ignore_constraints){ 1087 av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n"); 1088 ignore_constraints= 1; 1089 } 1090 scr= FFMAX(best_dts+1, scr); 1091 if(remove_decoded_packets(ctx, scr) < 0) 1092 return -1; 1093 goto retry; 1094 } 1095 1096 assert(best_i >= 0); 1097 1098 st = ctx->streams[best_i]; 1099 stream = st->priv_data; 1100 1101 assert(av_fifo_size(stream->fifo) > 0); 1102 1103 assert(avail_space >= s->packet_size || ignore_constraints); 1104 1105 timestamp_packet= stream->premux_packet; 1106 if(timestamp_packet->unwritten_size == timestamp_packet->size){ 1107 trailer_size= 0; 1108 }else{ 1109 trailer_size= timestamp_packet->unwritten_size; 1110 timestamp_packet= timestamp_packet->next; 1111 } 1112 1113 if(timestamp_packet){ 1114//av_log(ctx, AV_LOG_DEBUG, "dts:%f pts:%f scr:%f stream:%d\n", timestamp_packet->dts/90000.0, timestamp_packet->pts/90000.0, scr/90000.0, best_i); 1115 es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size); 1116 }else{ 1117 assert(av_fifo_size(stream->fifo) == trailer_size); 1118 es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size); 1119 } 1120 1121 if (s->is_vcd) { 1122 /* Write one or more padding sectors, if necessary, to reach 1123 the constant overall bitrate.*/ 1124 int vcd_pad_bytes; 1125 1126 while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here 1127 put_vcd_padding_sector(ctx); 1128 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet 1129 } 1130 } 1131 1132 stream->buffer_index += es_size; 1133 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet 1134 1135 while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){ 1136 es_size -= stream->premux_packet->unwritten_size; 1137 stream->premux_packet= stream->premux_packet->next; 1138 } 1139 if(es_size) 1140 stream->premux_packet->unwritten_size -= es_size; 1141 1142 if(remove_decoded_packets(ctx, s->last_scr) < 0) 1143 return -1; 1144 1145 return 1; 1146} 1147 1148static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt) 1149{ 1150 MpegMuxContext *s = ctx->priv_data; 1151 int stream_index= pkt->stream_index; 1152 int size= pkt->size; 1153 uint8_t *buf= pkt->data; 1154 AVStream *st = ctx->streams[stream_index]; 1155 StreamInfo *stream = st->priv_data; 1156 int64_t pts, dts; 1157 PacketDesc *pkt_desc; 1158 const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE); 1159 const int is_iframe = st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (pkt->flags & AV_PKT_FLAG_KEY); 1160 1161 pts= pkt->pts; 1162 dts= pkt->dts; 1163 1164 if(pts != AV_NOPTS_VALUE) pts += preload; 1165 if(dts != AV_NOPTS_VALUE) dts += preload; 1166 1167//av_log(ctx, AV_LOG_DEBUG, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n", dts/90000.0, pts/90000.0, pkt->flags, pkt->stream_index, pts != AV_NOPTS_VALUE); 1168 if (!stream->premux_packet) 1169 stream->next_packet = &stream->premux_packet; 1170 *stream->next_packet= 1171 pkt_desc= av_mallocz(sizeof(PacketDesc)); 1172 pkt_desc->pts= pts; 1173 pkt_desc->dts= dts; 1174 pkt_desc->unwritten_size= 1175 pkt_desc->size= size; 1176 if(!stream->predecode_packet) 1177 stream->predecode_packet= pkt_desc; 1178 stream->next_packet= &pkt_desc->next; 1179 1180 if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0) 1181 return -1; 1182 1183 if (s->is_dvd){ 1184 if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder) 1185 stream->bytes_to_iframe = av_fifo_size(stream->fifo); 1186 stream->align_iframe = 1; 1187 stream->vobu_start_pts = pts; 1188 } 1189 } 1190 1191 av_fifo_generic_write(stream->fifo, buf, size, NULL); 1192 1193 for(;;){ 1194 int ret= output_packet(ctx, 0); 1195 if(ret<=0) 1196 return ret; 1197 } 1198} 1199 1200static int mpeg_mux_end(AVFormatContext *ctx) 1201{ 1202// MpegMuxContext *s = ctx->priv_data; 1203 StreamInfo *stream; 1204 int i; 1205 1206 for(;;){ 1207 int ret= output_packet(ctx, 1); 1208 if(ret<0) 1209 return ret; 1210 else if(ret==0) 1211 break; 1212 } 1213 1214 /* End header according to MPEG1 systems standard. We do not write 1215 it as it is usually not needed by decoders and because it 1216 complicates MPEG stream concatenation. */ 1217 //put_be32(ctx->pb, ISO_11172_END_CODE); 1218 //put_flush_packet(ctx->pb); 1219 1220 for(i=0;i<ctx->nb_streams;i++) { 1221 stream = ctx->streams[i]->priv_data; 1222 1223 assert(av_fifo_size(stream->fifo) == 0); 1224 av_fifo_free(stream->fifo); 1225 } 1226 return 0; 1227} 1228 1229#if CONFIG_MPEG1SYSTEM_MUXER 1230AVOutputFormat mpeg1system_muxer = { 1231 "mpeg", 1232 NULL_IF_CONFIG_SMALL("MPEG-1 System format"), 1233 "video/mpeg", 1234 "mpg,mpeg", 1235 sizeof(MpegMuxContext), 1236 CODEC_ID_MP2, 1237 CODEC_ID_MPEG1VIDEO, 1238 mpeg_mux_init, 1239 mpeg_mux_write_packet, 1240 mpeg_mux_end, 1241}; 1242#endif 1243#if CONFIG_MPEG1VCD_MUXER 1244AVOutputFormat mpeg1vcd_muxer = { 1245 "vcd", 1246 NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"), 1247 "video/mpeg", 1248 NULL, 1249 sizeof(MpegMuxContext), 1250 CODEC_ID_MP2, 1251 CODEC_ID_MPEG1VIDEO, 1252 mpeg_mux_init, 1253 mpeg_mux_write_packet, 1254 mpeg_mux_end, 1255}; 1256#endif 1257#if CONFIG_MPEG2VOB_MUXER 1258AVOutputFormat mpeg2vob_muxer = { 1259 "vob", 1260 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"), 1261 "video/mpeg", 1262 "vob", 1263 sizeof(MpegMuxContext), 1264 CODEC_ID_MP2, 1265 CODEC_ID_MPEG2VIDEO, 1266 mpeg_mux_init, 1267 mpeg_mux_write_packet, 1268 mpeg_mux_end, 1269}; 1270#endif 1271 1272/* Same as mpeg2vob_mux except that the pack size is 2324 */ 1273#if CONFIG_MPEG2SVCD_MUXER 1274AVOutputFormat mpeg2svcd_muxer = { 1275 "svcd", 1276 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"), 1277 "video/mpeg", 1278 "vob", 1279 sizeof(MpegMuxContext), 1280 CODEC_ID_MP2, 1281 CODEC_ID_MPEG2VIDEO, 1282 mpeg_mux_init, 1283 mpeg_mux_write_packet, 1284 mpeg_mux_end, 1285}; 1286#endif 1287 1288/* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */ 1289#if CONFIG_MPEG2DVD_MUXER 1290AVOutputFormat mpeg2dvd_muxer = { 1291 "dvd", 1292 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"), 1293 "video/mpeg", 1294 "dvd", 1295 sizeof(MpegMuxContext), 1296 CODEC_ID_MP2, 1297 CODEC_ID_MPEG2VIDEO, 1298 mpeg_mux_init, 1299 mpeg_mux_write_packet, 1300 mpeg_mux_end, 1301}; 1302#endif 1303