00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "libavutil/fifo.h"
00023 #include "libavcodec/put_bits.h"
00024 #include "avformat.h"
00025 #include "mpeg.h"
00026
00027 #define MAX_PAYLOAD_SIZE 4096
00028
00029
00030 #undef NDEBUG
00031 #include <assert.h>
00032
00033 typedef struct PacketDesc {
00034 int64_t pts;
00035 int64_t dts;
00036 int size;
00037 int unwritten_size;
00038 int flags;
00039 struct PacketDesc *next;
00040 } PacketDesc;
00041
00042 typedef struct {
00043 AVFifoBuffer *fifo;
00044 uint8_t id;
00045 int max_buffer_size;
00046 int buffer_index;
00047 PacketDesc *predecode_packet;
00048 PacketDesc *premux_packet;
00049 PacketDesc **next_packet;
00050 int packet_number;
00051 uint8_t lpcm_header[3];
00052 int lpcm_align;
00053 int bytes_to_iframe;
00054 int align_iframe;
00055 int64_t vobu_start_pts;
00056 } StreamInfo;
00057
00058 typedef struct {
00059 int packet_size;
00060 int packet_number;
00061 int pack_header_freq;
00062 int system_header_freq;
00063 int system_header_size;
00064 int mux_rate;
00065
00066 int audio_bound;
00067 int video_bound;
00068 int is_mpeg2;
00069 int is_vcd;
00070 int is_svcd;
00071 int is_dvd;
00072 int64_t last_scr;
00073
00074 double vcd_padding_bitrate;
00075 int64_t vcd_padding_bytes_written;
00076
00077 } MpegMuxContext;
00078
00079 extern AVOutputFormat ff_mpeg1vcd_muxer;
00080 extern AVOutputFormat ff_mpeg2dvd_muxer;
00081 extern AVOutputFormat ff_mpeg2svcd_muxer;
00082 extern AVOutputFormat ff_mpeg2vob_muxer;
00083
00084 static int put_pack_header(AVFormatContext *ctx,
00085 uint8_t *buf, int64_t timestamp)
00086 {
00087 MpegMuxContext *s = ctx->priv_data;
00088 PutBitContext pb;
00089
00090 init_put_bits(&pb, buf, 128);
00091
00092 put_bits32(&pb, PACK_START_CODE);
00093 if (s->is_mpeg2) {
00094 put_bits(&pb, 2, 0x1);
00095 } else {
00096 put_bits(&pb, 4, 0x2);
00097 }
00098 put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
00099 put_bits(&pb, 1, 1);
00100 put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
00101 put_bits(&pb, 1, 1);
00102 put_bits(&pb, 15, (uint32_t)((timestamp ) & 0x7fff));
00103 put_bits(&pb, 1, 1);
00104 if (s->is_mpeg2) {
00105
00106 put_bits(&pb, 9, 0);
00107 }
00108 put_bits(&pb, 1, 1);
00109 put_bits(&pb, 22, s->mux_rate);
00110 put_bits(&pb, 1, 1);
00111 if (s->is_mpeg2) {
00112 put_bits(&pb, 1, 1);
00113 put_bits(&pb, 5, 0x1f);
00114 put_bits(&pb, 3, 0);
00115 }
00116 flush_put_bits(&pb);
00117 return put_bits_ptr(&pb) - pb.buf;
00118 }
00119
00120 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
00121 {
00122 MpegMuxContext *s = ctx->priv_data;
00123 int size, i, private_stream_coded, id;
00124 PutBitContext pb;
00125
00126 init_put_bits(&pb, buf, 128);
00127
00128 put_bits32(&pb, SYSTEM_HEADER_START_CODE);
00129 put_bits(&pb, 16, 0);
00130 put_bits(&pb, 1, 1);
00131
00132 put_bits(&pb, 22, s->mux_rate);
00133 put_bits(&pb, 1, 1);
00134 if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
00135
00136 put_bits(&pb, 6, 0);
00137 } else
00138 put_bits(&pb, 6, s->audio_bound);
00139
00140 if (s->is_vcd) {
00141
00142 put_bits(&pb, 1, 0);
00143 put_bits(&pb, 1, 1);
00144 } else {
00145 put_bits(&pb, 1, 0);
00146 put_bits(&pb, 1, 0);
00147 }
00148
00149 if (s->is_vcd || s->is_dvd) {
00150
00151 put_bits(&pb, 1, 1);
00152 put_bits(&pb, 1, 1);
00153 } else {
00154 put_bits(&pb, 1, 0);
00155 put_bits(&pb, 1, 0);
00156 }
00157
00158 put_bits(&pb, 1, 1);
00159
00160 if (s->is_vcd && (only_for_stream_id & 0xe0) == AUDIO_ID) {
00161
00162 put_bits(&pb, 5, 0);
00163 } else
00164 put_bits(&pb, 5, s->video_bound);
00165
00166 if (s->is_dvd) {
00167 put_bits(&pb, 1, 0);
00168 put_bits(&pb, 7, 0x7f);
00169 } else
00170 put_bits(&pb, 8, 0xff);
00171
00172
00173
00174
00175
00176
00177 if (s->is_dvd) {
00178
00179 int P_STD_max_video = 0;
00180 int P_STD_max_mpeg_audio = 0;
00181 int P_STD_max_mpeg_PS1 = 0;
00182
00183 for(i=0;i<ctx->nb_streams;i++) {
00184 StreamInfo *stream = ctx->streams[i]->priv_data;
00185
00186 id = stream->id;
00187 if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
00188 P_STD_max_mpeg_PS1 = stream->max_buffer_size;
00189 } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) {
00190 P_STD_max_mpeg_audio = stream->max_buffer_size;
00191 } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) {
00192 P_STD_max_video = stream->max_buffer_size;
00193 }
00194 }
00195
00196
00197 put_bits(&pb, 8, 0xb9);
00198 put_bits(&pb, 2, 3);
00199 put_bits(&pb, 1, 1);
00200 put_bits(&pb, 13, P_STD_max_video / 1024);
00201
00202
00203 if (P_STD_max_mpeg_audio == 0)
00204 P_STD_max_mpeg_audio = 4096;
00205 put_bits(&pb, 8, 0xb8);
00206 put_bits(&pb, 2, 3);
00207 put_bits(&pb, 1, 0);
00208 put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
00209
00210
00211 put_bits(&pb, 8, 0xbd);
00212 put_bits(&pb, 2, 3);
00213 put_bits(&pb, 1, 0);
00214 put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
00215
00216
00217 put_bits(&pb, 8, 0xbf);
00218 put_bits(&pb, 2, 3);
00219 put_bits(&pb, 1, 1);
00220 put_bits(&pb, 13, 2);
00221 }
00222 else {
00223
00224 private_stream_coded = 0;
00225 for(i=0;i<ctx->nb_streams;i++) {
00226 StreamInfo *stream = ctx->streams[i]->priv_data;
00227
00228
00229
00230
00231
00232 if ( !s->is_vcd || stream->id==only_for_stream_id
00233 || only_for_stream_id==0) {
00234
00235 id = stream->id;
00236 if (id < 0xc0) {
00237
00238 if (private_stream_coded)
00239 continue;
00240 private_stream_coded = 1;
00241 id = 0xbd;
00242 }
00243 put_bits(&pb, 8, id);
00244 put_bits(&pb, 2, 3);
00245 if (id < 0xe0) {
00246
00247 put_bits(&pb, 1, 0);
00248 put_bits(&pb, 13, stream->max_buffer_size / 128);
00249 } else {
00250
00251 put_bits(&pb, 1, 1);
00252 put_bits(&pb, 13, stream->max_buffer_size / 1024);
00253 }
00254 }
00255 }
00256 }
00257
00258 flush_put_bits(&pb);
00259 size = put_bits_ptr(&pb) - pb.buf;
00260
00261 buf[4] = (size - 6) >> 8;
00262 buf[5] = (size - 6) & 0xff;
00263
00264 return size;
00265 }
00266
00267 static int get_system_header_size(AVFormatContext *ctx)
00268 {
00269 int buf_index, i, private_stream_coded;
00270 StreamInfo *stream;
00271 MpegMuxContext *s = ctx->priv_data;
00272
00273 if (s->is_dvd)
00274 return 18;
00275
00276 buf_index = 12;
00277 private_stream_coded = 0;
00278 for(i=0;i<ctx->nb_streams;i++) {
00279 stream = ctx->streams[i]->priv_data;
00280 if (stream->id < 0xc0) {
00281 if (private_stream_coded)
00282 continue;
00283 private_stream_coded = 1;
00284 }
00285 buf_index += 3;
00286 }
00287 return buf_index;
00288 }
00289
00290 static int mpeg_mux_init(AVFormatContext *ctx)
00291 {
00292 MpegMuxContext *s = ctx->priv_data;
00293 int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
00294 AVStream *st;
00295 StreamInfo *stream;
00296 int audio_bitrate;
00297 int video_bitrate;
00298
00299 s->packet_number = 0;
00300 s->is_vcd = (CONFIG_MPEG1VCD_MUXER && ctx->oformat == &ff_mpeg1vcd_muxer);
00301 s->is_svcd = (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer);
00302 s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER && ctx->oformat == &ff_mpeg2vob_muxer) ||
00303 (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer) ||
00304 (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer));
00305 s->is_dvd = (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer);
00306
00307 if(ctx->packet_size) {
00308 if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) {
00309 av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n",
00310 ctx->packet_size);
00311 goto fail;
00312 }
00313 s->packet_size = ctx->packet_size;
00314 } else
00315 s->packet_size = 2048;
00316
00317 s->vcd_padding_bytes_written = 0;
00318 s->vcd_padding_bitrate=0;
00319
00320 s->audio_bound = 0;
00321 s->video_bound = 0;
00322 mpa_id = AUDIO_ID;
00323 ac3_id = AC3_ID;
00324 dts_id = DTS_ID;
00325 mpv_id = VIDEO_ID;
00326 mps_id = SUB_ID;
00327 lpcm_id = LPCM_ID;
00328 for(i=0;i<ctx->nb_streams;i++) {
00329 st = ctx->streams[i];
00330 stream = av_mallocz(sizeof(StreamInfo));
00331 if (!stream)
00332 goto fail;
00333 st->priv_data = stream;
00334
00335 av_set_pts_info(st, 64, 1, 90000);
00336
00337 switch(st->codec->codec_type) {
00338 case AVMEDIA_TYPE_AUDIO:
00339 if (st->codec->codec_id == CODEC_ID_AC3) {
00340 stream->id = ac3_id++;
00341 } else if (st->codec->codec_id == CODEC_ID_DTS) {
00342 stream->id = dts_id++;
00343 } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
00344 stream->id = lpcm_id++;
00345 for(j = 0; j < 4; j++) {
00346 if (lpcm_freq_tab[j] == st->codec->sample_rate)
00347 break;
00348 }
00349 if (j == 4)
00350 goto fail;
00351 if (st->codec->channels > 8)
00352 return -1;
00353 stream->lpcm_header[0] = 0x0c;
00354 stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
00355 stream->lpcm_header[2] = 0x80;
00356 stream->lpcm_align = st->codec->channels * 2;
00357 } else {
00358 stream->id = mpa_id++;
00359 }
00360
00361
00362
00363 stream->max_buffer_size = 4 * 1024;
00364 s->audio_bound++;
00365 break;
00366 case AVMEDIA_TYPE_VIDEO:
00367 stream->id = mpv_id++;
00368 if (st->codec->rc_buffer_size)
00369 stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
00370 else {
00371 av_log(ctx, AV_LOG_WARNING, "VBV buffer size not set, muxing may fail\n");
00372 stream->max_buffer_size = 230*1024;
00373 }
00374 #if 0
00375
00376 stream->max_buffer_size = 46 * 1024;
00377 else
00378
00379
00380 stream->max_buffer_size = 230 * 1024;
00381 #endif
00382 s->video_bound++;
00383 break;
00384 case AVMEDIA_TYPE_SUBTITLE:
00385 stream->id = mps_id++;
00386 stream->max_buffer_size = 16 * 1024;
00387 break;
00388 default:
00389 return -1;
00390 }
00391 stream->fifo= av_fifo_alloc(16);
00392 if (!stream->fifo)
00393 goto fail;
00394 }
00395 bitrate = 0;
00396 audio_bitrate = 0;
00397 video_bitrate = 0;
00398 for(i=0;i<ctx->nb_streams;i++) {
00399 int codec_rate;
00400 st = ctx->streams[i];
00401 stream = (StreamInfo*) st->priv_data;
00402
00403 if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
00404 codec_rate= st->codec->rc_max_rate;
00405 else
00406 codec_rate= st->codec->bit_rate;
00407
00408 if(!codec_rate)
00409 codec_rate= (1<<21)*8*50/ctx->nb_streams;
00410
00411 bitrate += codec_rate;
00412
00413 if ((stream->id & 0xe0) == AUDIO_ID)
00414 audio_bitrate += codec_rate;
00415 else if (stream->id==VIDEO_ID)
00416 video_bitrate += codec_rate;
00417 }
00418
00419 if(ctx->mux_rate){
00420 s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
00421 } else {
00422
00423
00424 bitrate += bitrate*5/100;
00425 bitrate += 10000;
00426 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
00427 }
00428
00429 if (s->is_vcd) {
00430 double overhead_rate;
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450 overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
00451 overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
00452 overhead_rate *= 8;
00453
00454
00455 s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
00456 }
00457
00458 if (s->is_vcd || s->is_mpeg2)
00459
00460 s->pack_header_freq = 1;
00461 else
00462
00463 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
00464
00465
00466 if (s->pack_header_freq == 0)
00467 s->pack_header_freq = 1;
00468
00469 if (s->is_mpeg2)
00470
00471 s->system_header_freq = s->pack_header_freq * 40;
00472 else if (s->is_vcd)
00473
00474
00475
00476 s->system_header_freq = 0x7fffffff;
00477 else
00478 s->system_header_freq = s->pack_header_freq * 5;
00479
00480 for(i=0;i<ctx->nb_streams;i++) {
00481 stream = ctx->streams[i]->priv_data;
00482 stream->packet_number = 0;
00483 }
00484 s->system_header_size = get_system_header_size(ctx);
00485 s->last_scr = 0;
00486 return 0;
00487 fail:
00488 for(i=0;i<ctx->nb_streams;i++) {
00489 av_free(ctx->streams[i]->priv_data);
00490 }
00491 return AVERROR(ENOMEM);
00492 }
00493
00494 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
00495 {
00496 avio_w8(pb,
00497 (id << 4) |
00498 (((timestamp >> 30) & 0x07) << 1) |
00499 1);
00500 avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
00501 avio_wb16(pb, (uint16_t)((((timestamp ) & 0x7fff) << 1) | 1));
00502 }
00503
00504
00505
00506
00507 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
00508 {
00509 MpegMuxContext *s = ctx->priv_data;
00510 int pad_bytes = 0;
00511
00512 if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
00513 {
00514 int64_t full_pad_bytes;
00515
00516 full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0);
00517 pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
00518
00519 if (pad_bytes<0)
00520
00521
00522 pad_bytes=0;
00523 }
00524
00525 return pad_bytes;
00526 }
00527
00528
00529 #if 0
00530
00531
00532
00533 static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
00534 int64_t pts, int64_t dts)
00535 {
00536 MpegMuxContext *s = ctx->priv_data;
00537 int buf_index;
00538 StreamInfo *stream;
00539
00540 stream = ctx->streams[stream_index]->priv_data;
00541
00542 buf_index = 0;
00543 if (((s->packet_number % s->pack_header_freq) == 0)) {
00544
00545 if (s->is_mpeg2)
00546 buf_index += 14;
00547 else
00548 buf_index += 12;
00549
00550 if (s->is_vcd) {
00551
00552
00553
00554
00555 if (stream->packet_number==0)
00556
00557
00558 buf_index += 15;
00559
00560 } else {
00561 if ((s->packet_number % s->system_header_freq) == 0)
00562 buf_index += s->system_header_size;
00563 }
00564 }
00565
00566 if ((s->is_vcd && stream->packet_number==0)
00567 || (s->is_svcd && s->packet_number==0))
00568
00569
00570
00571 buf_index += s->packet_size - buf_index;
00572 else {
00573
00574 buf_index += 6;
00575 if (s->is_mpeg2) {
00576 buf_index += 3;
00577 if (stream->packet_number==0)
00578 buf_index += 3;
00579 buf_index += 1;
00580 }
00581 if (pts != AV_NOPTS_VALUE) {
00582 if (dts != pts)
00583 buf_index += 5 + 5;
00584 else
00585 buf_index += 5;
00586
00587 } else {
00588 if (!s->is_mpeg2)
00589 buf_index++;
00590 }
00591
00592 if (stream->id < 0xc0) {
00593
00594 buf_index += 4;
00595 if (stream->id >= 0xa0) {
00596 int n;
00597 buf_index += 3;
00598
00599
00600 n = (s->packet_size - buf_index) % stream->lpcm_align;
00601 if (n)
00602 buf_index += (stream->lpcm_align - n);
00603 }
00604 }
00605
00606 if (s->is_vcd && (stream->id & 0xe0) == AUDIO_ID)
00607
00608
00609 buf_index+=20;
00610 }
00611 return s->packet_size - buf_index;
00612 }
00613 #endif
00614
00615
00616 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,int packet_bytes)
00617 {
00618 MpegMuxContext *s = ctx->priv_data;
00619 int i;
00620
00621 avio_wb32(pb, PADDING_STREAM);
00622 avio_wb16(pb, packet_bytes - 6);
00623 if (!s->is_mpeg2) {
00624 avio_w8(pb, 0x0f);
00625 packet_bytes -= 7;
00626 } else
00627 packet_bytes -= 6;
00628
00629 for(i=0;i<packet_bytes;i++)
00630 avio_w8(pb, 0xff);
00631 }
00632
00633 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
00634 int nb_frames=0;
00635 PacketDesc *pkt_desc= stream->premux_packet;
00636
00637 while(len>0){
00638 if(pkt_desc->size == pkt_desc->unwritten_size)
00639 nb_frames++;
00640 len -= pkt_desc->unwritten_size;
00641 pkt_desc= pkt_desc->next;
00642 }
00643
00644 return nb_frames;
00645 }
00646
00647
00648 static int flush_packet(AVFormatContext *ctx, int stream_index,
00649 int64_t pts, int64_t dts, int64_t scr, int trailer_size)
00650 {
00651 MpegMuxContext *s = ctx->priv_data;
00652 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
00653 uint8_t *buf_ptr;
00654 int size, payload_size, startcode, id, stuffing_size, i, header_len;
00655 int packet_size;
00656 uint8_t buffer[128];
00657 int zero_trail_bytes = 0;
00658 int pad_packet_bytes = 0;
00659 int pes_flags;
00660 int general_pack = 0;
00661 int nb_frames;
00662
00663 id = stream->id;
00664
00665 #if 0
00666 printf("packet ID=%2x PTS=%0.3f\n",
00667 id, pts / 90000.0);
00668 #endif
00669
00670 buf_ptr = buffer;
00671
00672 if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
00673
00674 size = put_pack_header(ctx, buf_ptr, scr);
00675 buf_ptr += size;
00676 s->last_scr= scr;
00677
00678 if (s->is_vcd) {
00679
00680
00681
00682
00683 if (stream->packet_number==0) {
00684 size = put_system_header(ctx, buf_ptr, id);
00685 buf_ptr += size;
00686 }
00687 } else if (s->is_dvd) {
00688 if (stream->align_iframe || s->packet_number == 0){
00689 int PES_bytes_to_fill = s->packet_size - size - 10;
00690
00691 if (pts != AV_NOPTS_VALUE) {
00692 if (dts != pts)
00693 PES_bytes_to_fill -= 5 + 5;
00694 else
00695 PES_bytes_to_fill -= 5;
00696 }
00697
00698 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
00699 size = put_system_header(ctx, buf_ptr, 0);
00700 buf_ptr += size;
00701 size = buf_ptr - buffer;
00702 avio_write(ctx->pb, buffer, size);
00703
00704 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
00705 avio_wb16(ctx->pb, 0x03d4);
00706 avio_w8(ctx->pb, 0x00);
00707 for (i = 0; i < 979; i++)
00708 avio_w8(ctx->pb, 0x00);
00709
00710 avio_wb32(ctx->pb, PRIVATE_STREAM_2);
00711 avio_wb16(ctx->pb, 0x03fa);
00712 avio_w8(ctx->pb, 0x01);
00713 for (i = 0; i < 1017; i++)
00714 avio_w8(ctx->pb, 0x00);
00715
00716 memset(buffer, 0, 128);
00717 buf_ptr = buffer;
00718 s->packet_number++;
00719 stream->align_iframe = 0;
00720 scr += s->packet_size*90000LL / (s->mux_rate*50LL);
00721 size = put_pack_header(ctx, buf_ptr, scr);
00722 s->last_scr= scr;
00723 buf_ptr += size;
00724
00725 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
00726 pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
00727 }
00728 }
00729 } else {
00730 if ((s->packet_number % s->system_header_freq) == 0) {
00731 size = put_system_header(ctx, buf_ptr, 0);
00732 buf_ptr += size;
00733 }
00734 }
00735 }
00736 size = buf_ptr - buffer;
00737 avio_write(ctx->pb, buffer, size);
00738
00739 packet_size = s->packet_size - size;
00740
00741 if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
00742
00743
00744 zero_trail_bytes += 20;
00745
00746 if ((s->is_vcd && stream->packet_number==0)
00747 || (s->is_svcd && s->packet_number==0)) {
00748
00749
00750
00751
00752
00753
00754 if (s->is_svcd)
00755 general_pack = 1;
00756 pad_packet_bytes = packet_size - zero_trail_bytes;
00757 }
00758
00759 packet_size -= pad_packet_bytes + zero_trail_bytes;
00760
00761 if (packet_size > 0) {
00762
00763
00764 packet_size -= 6;
00765
00766
00767 if (s->is_mpeg2) {
00768 header_len = 3;
00769 if (stream->packet_number==0)
00770 header_len += 3;
00771 header_len += 1;
00772 } else {
00773 header_len = 0;
00774 }
00775 if (pts != AV_NOPTS_VALUE) {
00776 if (dts != pts)
00777 header_len += 5 + 5;
00778 else
00779 header_len += 5;
00780 } else {
00781 if (!s->is_mpeg2)
00782 header_len++;
00783 }
00784
00785 payload_size = packet_size - header_len;
00786 if (id < 0xc0) {
00787 startcode = PRIVATE_STREAM_1;
00788 payload_size -= 1;
00789 if (id >= 0x40) {
00790 payload_size -= 3;
00791 if (id >= 0xa0)
00792 payload_size -= 3;
00793 }
00794 } else {
00795 startcode = 0x100 + id;
00796 }
00797
00798 stuffing_size = payload_size - av_fifo_size(stream->fifo);
00799
00800
00801 if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
00802 int timestamp_len=0;
00803 if(dts != pts)
00804 timestamp_len += 5;
00805 if(pts != AV_NOPTS_VALUE)
00806 timestamp_len += s->is_mpeg2 ? 5 : 4;
00807 pts=dts= AV_NOPTS_VALUE;
00808 header_len -= timestamp_len;
00809 if (s->is_dvd && stream->align_iframe) {
00810 pad_packet_bytes += timestamp_len;
00811 packet_size -= timestamp_len;
00812 } else {
00813 payload_size += timestamp_len;
00814 }
00815 stuffing_size += timestamp_len;
00816 if(payload_size > trailer_size)
00817 stuffing_size += payload_size - trailer_size;
00818 }
00819
00820 if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) {
00821 packet_size += pad_packet_bytes;
00822 payload_size += pad_packet_bytes;
00823 if (stuffing_size < 0) {
00824 stuffing_size = pad_packet_bytes;
00825 } else {
00826 stuffing_size += pad_packet_bytes;
00827 }
00828 pad_packet_bytes = 0;
00829 }
00830
00831 if (stuffing_size < 0)
00832 stuffing_size = 0;
00833 if (stuffing_size > 16) {
00834 pad_packet_bytes += stuffing_size;
00835 packet_size -= stuffing_size;
00836 payload_size -= stuffing_size;
00837 stuffing_size = 0;
00838 }
00839
00840 nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
00841
00842 avio_wb32(ctx->pb, startcode);
00843
00844 avio_wb16(ctx->pb, packet_size);
00845
00846 if (!s->is_mpeg2)
00847 for(i=0;i<stuffing_size;i++)
00848 avio_w8(ctx->pb, 0xff);
00849
00850 if (s->is_mpeg2) {
00851 avio_w8(ctx->pb, 0x80);
00852
00853 pes_flags=0;
00854
00855 if (pts != AV_NOPTS_VALUE) {
00856 pes_flags |= 0x80;
00857 if (dts != pts)
00858 pes_flags |= 0x40;
00859 }
00860
00861
00862
00863
00864
00865 if (stream->packet_number == 0)
00866 pes_flags |= 0x01;
00867
00868 avio_w8(ctx->pb, pes_flags);
00869 avio_w8(ctx->pb, header_len - 3 + stuffing_size);
00870
00871 if (pes_flags & 0x80)
00872 put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
00873 if (pes_flags & 0x40)
00874 put_timestamp(ctx->pb, 0x01, dts);
00875
00876 if (pes_flags & 0x01) {
00877 avio_w8(ctx->pb, 0x10);
00878
00879
00880 if ((id & 0xe0) == AUDIO_ID)
00881 avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size/ 128);
00882 else
00883 avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size/1024);
00884 }
00885
00886 } else {
00887 if (pts != AV_NOPTS_VALUE) {
00888 if (dts != pts) {
00889 put_timestamp(ctx->pb, 0x03, pts);
00890 put_timestamp(ctx->pb, 0x01, dts);
00891 } else {
00892 put_timestamp(ctx->pb, 0x02, pts);
00893 }
00894 } else {
00895 avio_w8(ctx->pb, 0x0f);
00896 }
00897 }
00898
00899 if (s->is_mpeg2) {
00900
00901
00902 avio_w8(ctx->pb, 0xff);
00903
00904 for(i=0;i<stuffing_size;i++)
00905 avio_w8(ctx->pb, 0xff);
00906 }
00907
00908 if (startcode == PRIVATE_STREAM_1) {
00909 avio_w8(ctx->pb, id);
00910 if (id >= 0xa0) {
00911
00912 avio_w8(ctx->pb, 7);
00913 avio_wb16(ctx->pb, 4);
00914 avio_w8(ctx->pb, stream->lpcm_header[0]);
00915 avio_w8(ctx->pb, stream->lpcm_header[1]);
00916 avio_w8(ctx->pb, stream->lpcm_header[2]);
00917 } else if (id >= 0x40) {
00918
00919 avio_w8(ctx->pb, nb_frames);
00920 avio_wb16(ctx->pb, trailer_size+1);
00921 }
00922 }
00923
00924
00925 assert(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
00926 av_fifo_generic_read(stream->fifo, ctx->pb, payload_size - stuffing_size, &avio_write);
00927 stream->bytes_to_iframe -= payload_size - stuffing_size;
00928 }else{
00929 payload_size=
00930 stuffing_size= 0;
00931 }
00932
00933 if (pad_packet_bytes > 0)
00934 put_padding_packet(ctx,ctx->pb, pad_packet_bytes);
00935
00936 for(i=0;i<zero_trail_bytes;i++)
00937 avio_w8(ctx->pb, 0x00);
00938
00939 put_flush_packet(ctx->pb);
00940
00941 s->packet_number++;
00942
00943
00944
00945
00946 if (!general_pack)
00947 stream->packet_number++;
00948
00949 return payload_size - stuffing_size;
00950 }
00951
00952 static void put_vcd_padding_sector(AVFormatContext *ctx)
00953 {
00954
00955
00956
00957
00958
00959
00960 MpegMuxContext *s = ctx->priv_data;
00961 int i;
00962
00963 for(i=0;i<s->packet_size;i++)
00964 avio_w8(ctx->pb, 0);
00965
00966 s->vcd_padding_bytes_written += s->packet_size;
00967
00968 put_flush_packet(ctx->pb);
00969
00970
00971
00972
00973
00974 s->packet_number++;
00975 }
00976
00977 #if 0
00978 static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
00979 {
00980 MpegMuxContext *s = ctx->priv_data;
00981 int64_t scr;
00982
00983
00984
00985
00986
00987
00988
00989
00990
00991
00992
00993 scr = 36000 + s->packet_number * 1200;
00994
00995 return scr;
00996 }
00997 #endif
00998
00999 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
01000
01001 int i;
01002
01003 for(i=0; i<ctx->nb_streams; i++){
01004 AVStream *st = ctx->streams[i];
01005 StreamInfo *stream = st->priv_data;
01006 PacketDesc *pkt_desc;
01007
01008 while((pkt_desc= stream->predecode_packet)
01009 && scr > pkt_desc->dts){
01010 if(stream->buffer_index < pkt_desc->size ||
01011 stream->predecode_packet == stream->premux_packet){
01012 av_log(ctx, AV_LOG_ERROR,
01013 "buffer underflow i=%d bufi=%d size=%d\n",
01014 i, stream->buffer_index, pkt_desc->size);
01015 break;
01016 }
01017 stream->buffer_index -= pkt_desc->size;
01018
01019 stream->predecode_packet= pkt_desc->next;
01020 av_freep(&pkt_desc);
01021 }
01022 }
01023
01024 return 0;
01025 }
01026
01027 static int output_packet(AVFormatContext *ctx, int flush){
01028 MpegMuxContext *s = ctx->priv_data;
01029 AVStream *st;
01030 StreamInfo *stream;
01031 int i, avail_space=0, es_size, trailer_size;
01032 int best_i= -1;
01033 int best_score= INT_MIN;
01034 int ignore_constraints=0;
01035 int64_t scr= s->last_scr;
01036 PacketDesc *timestamp_packet;
01037 const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
01038
01039 retry:
01040 for(i=0; i<ctx->nb_streams; i++){
01041 AVStream *st = ctx->streams[i];
01042 StreamInfo *stream = st->priv_data;
01043 const int avail_data= av_fifo_size(stream->fifo);
01044 const int space= stream->max_buffer_size - stream->buffer_index;
01045 int rel_space= 1024*space / stream->max_buffer_size;
01046 PacketDesc *next_pkt= stream->premux_packet;
01047
01048
01049
01050 if(s->packet_size > avail_data && !flush
01051 && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
01052 return 0;
01053 if(avail_data==0)
01054 continue;
01055 assert(avail_data>0);
01056
01057 if(space < s->packet_size && !ignore_constraints)
01058 continue;
01059
01060 if(next_pkt && next_pkt->dts - scr > max_delay)
01061 continue;
01062
01063 if(rel_space > best_score){
01064 best_score= rel_space;
01065 best_i = i;
01066 avail_space= space;
01067 }
01068 }
01069
01070 if(best_i < 0){
01071 int64_t best_dts= INT64_MAX;
01072
01073 for(i=0; i<ctx->nb_streams; i++){
01074 AVStream *st = ctx->streams[i];
01075 StreamInfo *stream = st->priv_data;
01076 PacketDesc *pkt_desc= stream->predecode_packet;
01077 if(pkt_desc && pkt_desc->dts < best_dts)
01078 best_dts= pkt_desc->dts;
01079 }
01080
01081 #if 0
01082 av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n",
01083 scr/90000.0, best_dts/90000.0);
01084 #endif
01085 if(best_dts == INT64_MAX)
01086 return 0;
01087
01088 if(scr >= best_dts+1 && !ignore_constraints){
01089 av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
01090 ignore_constraints= 1;
01091 }
01092 scr= FFMAX(best_dts+1, scr);
01093 if(remove_decoded_packets(ctx, scr) < 0)
01094 return -1;
01095 goto retry;
01096 }
01097
01098 assert(best_i >= 0);
01099
01100 st = ctx->streams[best_i];
01101 stream = st->priv_data;
01102
01103 assert(av_fifo_size(stream->fifo) > 0);
01104
01105 assert(avail_space >= s->packet_size || ignore_constraints);
01106
01107 timestamp_packet= stream->premux_packet;
01108 if(timestamp_packet->unwritten_size == timestamp_packet->size){
01109 trailer_size= 0;
01110 }else{
01111 trailer_size= timestamp_packet->unwritten_size;
01112 timestamp_packet= timestamp_packet->next;
01113 }
01114
01115 if(timestamp_packet){
01116
01117 es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
01118 }else{
01119 assert(av_fifo_size(stream->fifo) == trailer_size);
01120 es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
01121 }
01122
01123 if (s->is_vcd) {
01124
01125
01126 int vcd_pad_bytes;
01127
01128 while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){
01129 put_vcd_padding_sector(ctx);
01130 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL);
01131 }
01132 }
01133
01134 stream->buffer_index += es_size;
01135 s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL);
01136
01137 while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
01138 es_size -= stream->premux_packet->unwritten_size;
01139 stream->premux_packet= stream->premux_packet->next;
01140 }
01141 if(es_size)
01142 stream->premux_packet->unwritten_size -= es_size;
01143
01144 if(remove_decoded_packets(ctx, s->last_scr) < 0)
01145 return -1;
01146
01147 return 1;
01148 }
01149
01150 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
01151 {
01152 MpegMuxContext *s = ctx->priv_data;
01153 int stream_index= pkt->stream_index;
01154 int size= pkt->size;
01155 uint8_t *buf= pkt->data;
01156 AVStream *st = ctx->streams[stream_index];
01157 StreamInfo *stream = st->priv_data;
01158 int64_t pts, dts;
01159 PacketDesc *pkt_desc;
01160 const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
01161 const int is_iframe = st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (pkt->flags & AV_PKT_FLAG_KEY);
01162
01163 pts= pkt->pts;
01164 dts= pkt->dts;
01165
01166 if(pts != AV_NOPTS_VALUE) pts += 2*preload;
01167 if(dts != AV_NOPTS_VALUE){
01168 if(!s->last_scr)
01169 s->last_scr= dts + preload;
01170 dts += 2*preload;
01171 }
01172
01173
01174 if (!stream->premux_packet)
01175 stream->next_packet = &stream->premux_packet;
01176 *stream->next_packet=
01177 pkt_desc= av_mallocz(sizeof(PacketDesc));
01178 pkt_desc->pts= pts;
01179 pkt_desc->dts= dts;
01180 pkt_desc->unwritten_size=
01181 pkt_desc->size= size;
01182 if(!stream->predecode_packet)
01183 stream->predecode_packet= pkt_desc;
01184 stream->next_packet= &pkt_desc->next;
01185
01186 if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
01187 return -1;
01188
01189 if (s->is_dvd){
01190 if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) {
01191 stream->bytes_to_iframe = av_fifo_size(stream->fifo);
01192 stream->align_iframe = 1;
01193 stream->vobu_start_pts = pts;
01194 }
01195 }
01196
01197 av_fifo_generic_write(stream->fifo, buf, size, NULL);
01198
01199 for(;;){
01200 int ret= output_packet(ctx, 0);
01201 if(ret<=0)
01202 return ret;
01203 }
01204 }
01205
01206 static int mpeg_mux_end(AVFormatContext *ctx)
01207 {
01208
01209 StreamInfo *stream;
01210 int i;
01211
01212 for(;;){
01213 int ret= output_packet(ctx, 1);
01214 if(ret<0)
01215 return ret;
01216 else if(ret==0)
01217 break;
01218 }
01219
01220
01221
01222
01223
01224
01225
01226 for(i=0;i<ctx->nb_streams;i++) {
01227 stream = ctx->streams[i]->priv_data;
01228
01229 assert(av_fifo_size(stream->fifo) == 0);
01230 av_fifo_free(stream->fifo);
01231 }
01232 return 0;
01233 }
01234
01235 #if CONFIG_MPEG1SYSTEM_MUXER
01236 AVOutputFormat ff_mpeg1system_muxer = {
01237 "mpeg",
01238 NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
01239 "video/mpeg",
01240 "mpg,mpeg",
01241 sizeof(MpegMuxContext),
01242 CODEC_ID_MP2,
01243 CODEC_ID_MPEG1VIDEO,
01244 mpeg_mux_init,
01245 mpeg_mux_write_packet,
01246 mpeg_mux_end,
01247 };
01248 #endif
01249 #if CONFIG_MPEG1VCD_MUXER
01250 AVOutputFormat ff_mpeg1vcd_muxer = {
01251 "vcd",
01252 NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
01253 "video/mpeg",
01254 NULL,
01255 sizeof(MpegMuxContext),
01256 CODEC_ID_MP2,
01257 CODEC_ID_MPEG1VIDEO,
01258 mpeg_mux_init,
01259 mpeg_mux_write_packet,
01260 mpeg_mux_end,
01261 };
01262 #endif
01263 #if CONFIG_MPEG2VOB_MUXER
01264 AVOutputFormat ff_mpeg2vob_muxer = {
01265 "vob",
01266 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
01267 "video/mpeg",
01268 "vob",
01269 sizeof(MpegMuxContext),
01270 CODEC_ID_MP2,
01271 CODEC_ID_MPEG2VIDEO,
01272 mpeg_mux_init,
01273 mpeg_mux_write_packet,
01274 mpeg_mux_end,
01275 };
01276 #endif
01277
01278
01279 #if CONFIG_MPEG2SVCD_MUXER
01280 AVOutputFormat ff_mpeg2svcd_muxer = {
01281 "svcd",
01282 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
01283 "video/mpeg",
01284 "vob",
01285 sizeof(MpegMuxContext),
01286 CODEC_ID_MP2,
01287 CODEC_ID_MPEG2VIDEO,
01288 mpeg_mux_init,
01289 mpeg_mux_write_packet,
01290 mpeg_mux_end,
01291 };
01292 #endif
01293
01294
01295 #if CONFIG_MPEG2DVD_MUXER
01296 AVOutputFormat ff_mpeg2dvd_muxer = {
01297 "dvd",
01298 NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
01299 "video/mpeg",
01300 "dvd",
01301 sizeof(MpegMuxContext),
01302 CODEC_ID_MP2,
01303 CODEC_ID_MPEG2VIDEO,
01304 mpeg_mux_init,
01305 mpeg_mux_write_packet,
01306 mpeg_mux_end,
01307 };
01308 #endif