a5feba8758b223eb3675c873f369d43c0a24b421
[ffmpeg.git] / libavformat / mpeg.c
1 /*
2  * MPEG1/2 mux/demux
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  */
19 #include "avformat.h"
20
21 #define MAX_PAYLOAD_SIZE 4096
22 //#define DEBUG_SEEK
23
24 #undef NDEBUG
25 #include <assert.h>
26
27 typedef struct {
28     uint8_t buffer[MAX_PAYLOAD_SIZE];
29     int buffer_ptr;
30     int nb_frames;    /* number of starting frame encountered (AC3) */
31     int frame_start_offset; /* starting offset of the frame + 1 (0 if none) */
32     uint8_t id;
33     int max_buffer_size; /* in bytes */
34     int packet_number;
35     int64_t start_pts;
36     int64_t start_dts;
37     uint8_t lpcm_header[3];
38     int lpcm_align;
39 } StreamInfo;
40
41 typedef struct {
42     int packet_size; /* required packet size */
43     int packet_number;
44     int pack_header_freq;     /* frequency (in packets^-1) at which we send pack headers */
45     int system_header_freq;
46     int system_header_size;
47     int mux_rate; /* bitrate in units of 50 bytes/s */
48     /* stream info */
49     int audio_bound;
50     int video_bound;
51     int is_mpeg2;
52     int is_vcd;
53     int is_svcd;
54     int scr_stream_index; /* stream from which the system clock is
55                              computed (VBR case) */
56     int64_t last_scr; /* current system clock */
57
58     double vcd_padding_bitrate;
59     int64_t vcd_padding_bytes_written;
60
61 } MpegMuxContext;
62
63 #define PACK_START_CODE             ((unsigned int)0x000001ba)
64 #define SYSTEM_HEADER_START_CODE    ((unsigned int)0x000001bb)
65 #define SEQUENCE_END_CODE           ((unsigned int)0x000001b7)
66 #define PACKET_START_CODE_MASK      ((unsigned int)0xffffff00)
67 #define PACKET_START_CODE_PREFIX    ((unsigned int)0x00000100)
68 #define ISO_11172_END_CODE          ((unsigned int)0x000001b9)
69   
70 /* mpeg2 */
71 #define PROGRAM_STREAM_MAP 0x1bc
72 #define PRIVATE_STREAM_1   0x1bd
73 #define PADDING_STREAM     0x1be
74 #define PRIVATE_STREAM_2   0x1bf
75
76
77 #define AUDIO_ID 0xc0
78 #define VIDEO_ID 0xe0
79 #define AC3_ID   0x80
80 #define LPCM_ID  0xa0
81
82 static const int lpcm_freq_tab[4] = { 48000, 96000, 44100, 32000 };
83
84 #ifdef CONFIG_ENCODERS
85 static AVOutputFormat mpeg1system_mux;
86 static AVOutputFormat mpeg1vcd_mux;
87 static AVOutputFormat mpeg2vob_mux;
88 static AVOutputFormat mpeg2svcd_mux;
89
90 static int put_pack_header(AVFormatContext *ctx, 
91                            uint8_t *buf, int64_t timestamp)
92 {
93     MpegMuxContext *s = ctx->priv_data;
94     PutBitContext pb;
95     
96     init_put_bits(&pb, buf, 128);
97
98     put_bits(&pb, 32, PACK_START_CODE);
99     if (s->is_mpeg2) {
100         put_bits(&pb, 2, 0x1);
101     } else {
102         put_bits(&pb, 4, 0x2);
103     }
104     put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
105     put_bits(&pb, 1, 1);
106     put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
107     put_bits(&pb, 1, 1);
108     put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
109     put_bits(&pb, 1, 1);
110     if (s->is_mpeg2) {
111         /* clock extension */
112         put_bits(&pb, 9, 0);
113     }
114     put_bits(&pb, 1, 1);
115     put_bits(&pb, 22, s->mux_rate);
116     put_bits(&pb, 1, 1);
117     if (s->is_mpeg2) {
118         put_bits(&pb, 1, 1);
119         put_bits(&pb, 5, 0x1f); /* reserved */
120         put_bits(&pb, 3, 0); /* stuffing length */
121     }
122     flush_put_bits(&pb);
123     return pbBufPtr(&pb) - pb.buf;
124 }
125
126 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
127 {
128     MpegMuxContext *s = ctx->priv_data;
129     int size, rate_bound, i, private_stream_coded, id;
130     PutBitContext pb;
131
132     init_put_bits(&pb, buf, 128);
133
134     put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
135     put_bits(&pb, 16, 0);
136     put_bits(&pb, 1, 1);
137     
138     rate_bound = s->mux_rate; /* maximum bit rate of the multiplexed stream */
139     put_bits(&pb, 22, rate_bound);
140     put_bits(&pb, 1, 1); /* marker */
141     if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
142         /* This header applies only to the video stream (see VCD standard p. IV-7)*/
143         put_bits(&pb, 6, 0);
144     } else
145         put_bits(&pb, 6, s->audio_bound);
146
147     if (s->is_vcd) {
148         /* see VCD standard, p. IV-7*/
149         put_bits(&pb, 1, 0); 
150         put_bits(&pb, 1, 1);
151     } else {
152         put_bits(&pb, 1, 0); /* variable bitrate*/
153         put_bits(&pb, 1, 0); /* non constrainted bit stream */
154     }
155     
156     if (s->is_vcd) {
157         /* see VCD standard p IV-7 */
158         put_bits(&pb, 1, 1); /* audio locked */
159         put_bits(&pb, 1, 1); /* video locked */
160     } else {
161         put_bits(&pb, 1, 0); /* audio locked */
162         put_bits(&pb, 1, 0); /* video locked */
163     }
164
165     put_bits(&pb, 1, 1); /* marker */
166
167     if (s->is_vcd && only_for_stream_id==AUDIO_ID) {
168         /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
169         put_bits(&pb, 5, 0);
170     } else
171         put_bits(&pb, 5, s->video_bound);
172
173     put_bits(&pb, 8, 0xff); /* reserved byte */
174     
175     /* audio stream info */
176     private_stream_coded = 0;
177     for(i=0;i<ctx->nb_streams;i++) {
178         StreamInfo *stream = ctx->streams[i]->priv_data;
179         
180         /* For VCDs, only include the stream info for the stream
181            that the pack which contains this system belongs to.
182            (see VCD standard p. IV-7) */
183         if ( !s->is_vcd || stream->id==only_for_stream_id
184             || only_for_stream_id==0) {
185
186             id = stream->id;
187             if (id < 0xc0) {
188                 /* special case for private streams (AC3 use that) */
189                 if (private_stream_coded)
190                     continue;
191                 private_stream_coded = 1;
192                 id = 0xbd;
193             }
194             put_bits(&pb, 8, id); /* stream ID */
195             put_bits(&pb, 2, 3);
196             if (id < 0xe0) {
197                 /* audio */
198                 put_bits(&pb, 1, 0);
199                 put_bits(&pb, 13, stream->max_buffer_size / 128);
200             } else {
201                 /* video */
202                 put_bits(&pb, 1, 1);
203                 put_bits(&pb, 13, stream->max_buffer_size / 1024);
204             }
205         }
206     }
207     flush_put_bits(&pb);
208     size = pbBufPtr(&pb) - pb.buf;
209     /* patch packet size */
210     buf[4] = (size - 6) >> 8;
211     buf[5] = (size - 6) & 0xff;
212
213     return size;
214 }
215
216 static int get_system_header_size(AVFormatContext *ctx)
217 {
218     int buf_index, i, private_stream_coded;
219     StreamInfo *stream;
220
221     buf_index = 12;
222     private_stream_coded = 0;
223     for(i=0;i<ctx->nb_streams;i++) {
224         stream = ctx->streams[i]->priv_data;
225         if (stream->id < 0xc0) {
226             if (private_stream_coded)
227                 continue;
228             private_stream_coded = 1;
229         }
230         buf_index += 3;
231     }
232     return buf_index;
233 }
234
235 static int mpeg_mux_init(AVFormatContext *ctx)
236 {
237     MpegMuxContext *s = ctx->priv_data;
238     int bitrate, i, mpa_id, mpv_id, ac3_id, lpcm_id, j;
239     AVStream *st;
240     StreamInfo *stream;
241     int audio_bitrate;
242     int video_bitrate;
243
244     s->packet_number = 0;
245     s->is_vcd = (ctx->oformat == &mpeg1vcd_mux);
246     s->is_svcd = (ctx->oformat == &mpeg2svcd_mux);
247     s->is_mpeg2 = (ctx->oformat == &mpeg2vob_mux || ctx->oformat == &mpeg2svcd_mux);
248     
249     if (s->is_vcd || s->is_svcd)
250         s->packet_size = 2324; /* VCD/SVCD packet size */
251     else
252         s->packet_size = 2048;
253
254     s->vcd_padding_bytes_written = 0;
255     s->vcd_padding_bitrate=0;
256         
257     s->audio_bound = 0;
258     s->video_bound = 0;
259     mpa_id = AUDIO_ID;
260     ac3_id = AC3_ID;
261     mpv_id = VIDEO_ID;
262     lpcm_id = LPCM_ID;
263     s->scr_stream_index = -1;
264     for(i=0;i<ctx->nb_streams;i++) {
265         st = ctx->streams[i];
266         stream = av_mallocz(sizeof(StreamInfo));
267         if (!stream)
268             goto fail;
269         st->priv_data = stream;
270
271         switch(st->codec.codec_type) {
272         case CODEC_TYPE_AUDIO:
273             if (st->codec.codec_id == CODEC_ID_AC3) {
274                 stream->id = ac3_id++;
275             } else if (st->codec.codec_id == CODEC_ID_PCM_S16BE) {
276                 stream->id = lpcm_id++;
277                 for(j = 0; j < 4; j++) {
278                     if (lpcm_freq_tab[j] == st->codec.sample_rate)
279                         break;
280                 }
281                 if (j == 4)
282                     goto fail;
283                 if (st->codec.channels > 8)
284                     return -1;
285                 stream->lpcm_header[0] = 0x0c;
286                 stream->lpcm_header[1] = (st->codec.channels - 1) | (j << 4);
287                 stream->lpcm_header[2] = 0x80;
288                 stream->lpcm_align = st->codec.channels * 2;
289             } else {
290                 stream->id = mpa_id++;
291             }
292
293             /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
294                Right now it is also used for everything else.*/
295             stream->max_buffer_size = 4 * 1024; 
296             s->audio_bound++;
297             break;
298         case CODEC_TYPE_VIDEO:
299             /* by default, video is used for the SCR computation */
300             if (s->scr_stream_index == -1)
301                 s->scr_stream_index = i;
302             stream->id = mpv_id++;
303             if (s->is_vcd)
304                 /* see VCD standard, p. IV-7*/
305                 stream->max_buffer_size = 46 * 1024; 
306             else
307                 /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
308                    Right now it is also used for everything else.*/
309                 stream->max_buffer_size = 230 * 1024; 
310             s->video_bound++;
311             break;
312         default:
313             av_abort();
314         }
315     }
316     /* if no SCR, use first stream (audio) */
317     if (s->scr_stream_index == -1)
318         s->scr_stream_index = 0;
319
320     bitrate = 0;
321     audio_bitrate = 0;
322     video_bitrate = 0;
323     for(i=0;i<ctx->nb_streams;i++) {
324         st = ctx->streams[i];
325         stream = (StreamInfo*) st->priv_data;
326         
327         bitrate += st->codec.bit_rate;
328
329         if (stream->id==AUDIO_ID)
330             audio_bitrate += st->codec.bit_rate;
331         else if (stream->id==VIDEO_ID)
332             video_bitrate += st->codec.bit_rate;
333     }
334
335     if (s->is_vcd) {
336         double overhead_rate;
337
338         /* The VCD standard mandates that the mux_rate field is 3528
339            (see standard p. IV-6).
340            The value is actually "wrong", i.e. if you calculate
341            it using the normal formula and the 75 sectors per second transfer
342            rate you get a different value because the real pack size is 2324,
343            not 2352. But the standard explicitly specifies that the mux_rate
344            field in the header must have this value.*/
345         s->mux_rate=2352 * 75 / 50;    /* = 3528*/
346
347         /* The VCD standard states that the muxed stream must be
348            exactly 75 packs / second (the data rate of a single speed cdrom).
349            Since the video bitrate (probably 1150000 bits/sec) will be below
350            the theoretical maximum we have to add some padding packets
351            to make up for the lower data rate.
352            (cf. VCD standard p. IV-6 )*/
353
354         /* Add the header overhead to the data rate.
355            2279 data bytes per audio pack, 2294 data bytes per video pack*/
356         overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
357         overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
358         overhead_rate *= 8;
359         
360         /* Add padding so that the full bitrate is 2324*75 bytes/sec */
361         s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
362
363     } else {
364         /* we increase slightly the bitrate to take into account the
365            headers. XXX: compute it exactly */
366         bitrate += 2000;
367         s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
368     }
369     
370     if (s->is_vcd || s->is_mpeg2)
371         /* every packet */
372         s->pack_header_freq = 1;
373     else
374         /* every 2 seconds */
375         s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
376
377     /* the above seems to make pack_header_freq zero sometimes */
378     if (s->pack_header_freq == 0)
379        s->pack_header_freq = 1;
380     
381     if (s->is_mpeg2)
382         /* every 200 packets. Need to look at the spec.  */
383         s->system_header_freq = s->pack_header_freq * 40;
384     else if (s->is_vcd)
385         /* the standard mandates that there are only two system headers
386            in the whole file: one in the first packet of each stream.
387            (see standard p. IV-7 and IV-8) */
388         s->system_header_freq = 0x7fffffff;
389     else
390         s->system_header_freq = s->pack_header_freq * 5;
391     
392     for(i=0;i<ctx->nb_streams;i++) {
393         stream = ctx->streams[i]->priv_data;
394         stream->buffer_ptr = 0;
395         stream->packet_number = 0;
396         stream->start_pts = AV_NOPTS_VALUE;
397         stream->start_dts = AV_NOPTS_VALUE;
398     }
399     s->system_header_size = get_system_header_size(ctx);
400     s->last_scr = 0;
401     return 0;
402  fail:
403     for(i=0;i<ctx->nb_streams;i++) {
404         av_free(ctx->streams[i]->priv_data);
405     }
406     return -ENOMEM;
407 }
408
409 static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
410 {
411     put_byte(pb, 
412              (id << 4) | 
413              (((timestamp >> 30) & 0x07) << 1) | 
414              1);
415     put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
416     put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
417 }
418
419
420 /* return the number of padding bytes that should be inserted into
421    the multiplexed stream.*/
422 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
423 {
424     MpegMuxContext *s = ctx->priv_data;
425     int pad_bytes = 0;
426
427     if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
428     {
429         int64_t full_pad_bytes;
430         
431         full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0);
432         pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
433
434         if (pad_bytes<0)
435             /* might happen if we have already padded to a later timestamp. This
436                can occur if another stream has already advanced further.*/
437             pad_bytes=0;
438     }
439
440     return pad_bytes;
441 }
442
443
444 /* return the exact available payload size for the next packet for
445    stream 'stream_index'. 'pts' and 'dts' are only used to know if
446    timestamps are needed in the packet header. */
447 static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
448                                    int64_t pts, int64_t dts)
449 {
450     MpegMuxContext *s = ctx->priv_data;
451     int buf_index;
452     StreamInfo *stream;
453
454     stream = ctx->streams[stream_index]->priv_data;
455
456     buf_index = 0;
457     if (((s->packet_number % s->pack_header_freq) == 0)) {
458         /* pack header size */
459         if (s->is_mpeg2) 
460             buf_index += 14;
461         else
462             buf_index += 12;
463         
464         if (s->is_vcd) {
465             /* there is exactly one system header for each stream in a VCD MPEG,
466                One in the very first video packet and one in the very first
467                audio packet (see VCD standard p. IV-7 and IV-8).*/
468             
469             if (stream->packet_number==0)
470                 /* The system headers refer only to the stream they occur in,
471                    so they have a constant size.*/
472                 buf_index += 15;
473
474         } else {            
475             if ((s->packet_number % s->system_header_freq) == 0)
476                 buf_index += s->system_header_size;
477         }
478     }
479
480     if ((s->is_vcd && stream->packet_number==0)
481         || (s->is_svcd && s->packet_number==0))
482         /* the first pack of each stream contains only the pack header,
483            the system header and some padding (see VCD standard p. IV-6) 
484            Add the padding size, so that the actual payload becomes 0.*/
485         buf_index += s->packet_size - buf_index;
486     else {
487         /* packet header size */
488         buf_index += 6;
489         if (s->is_mpeg2) {
490             buf_index += 3;
491             if (stream->packet_number==0)
492                 buf_index += 3; /* PES extension */
493             buf_index += 1;    /* obligatory stuffing byte */
494         }
495         if (pts != AV_NOPTS_VALUE) {
496             if (dts != pts)
497                 buf_index += 5 + 5;
498             else
499                 buf_index += 5;
500
501         } else {
502             if (!s->is_mpeg2)
503                 buf_index++;
504         }
505     
506         if (stream->id < 0xc0) {
507             /* AC3/LPCM private data header */
508             buf_index += 4;
509             if (stream->id >= 0xa0) {
510                 int n;
511                 buf_index += 3;
512                 /* NOTE: we round the payload size to an integer number of
513                    LPCM samples */
514                 n = (s->packet_size - buf_index) % stream->lpcm_align;
515                 if (n)
516                     buf_index += (stream->lpcm_align - n);
517             }
518         }
519
520         if (s->is_vcd && stream->id == AUDIO_ID)
521             /* The VCD standard demands that 20 zero bytes follow
522                each audio packet (see standard p. IV-8).*/
523             buf_index+=20;
524     }
525     return s->packet_size - buf_index; 
526 }
527
528 /* Write an MPEG padding packet header. */
529 static int put_padding_header(AVFormatContext *ctx,uint8_t* buf, int full_padding_size)
530 {
531     MpegMuxContext *s = ctx->priv_data;
532     int size = full_padding_size - 6;    /* subtract header length */
533
534     buf[0] = (uint8_t)(PADDING_STREAM >> 24);
535     buf[1] = (uint8_t)(PADDING_STREAM >> 16);
536     buf[2] = (uint8_t)(PADDING_STREAM >> 8);
537     buf[3] = (uint8_t)(PADDING_STREAM);
538     buf[4] = (uint8_t)(size >> 8);
539     buf[5] = (uint8_t)(size & 0xff);
540
541     if (!s->is_mpeg2) {
542         buf[6] = 0x0f;
543         return 7;
544     } else
545         return 6;
546 }
547
548 static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
549 {
550     uint8_t buffer[7];
551     int size, i;
552     
553     size = put_padding_header(ctx,buffer, packet_bytes);
554     put_buffer(pb, buffer, size);
555     packet_bytes -= size;
556
557     for(i=0;i<packet_bytes;i++)
558         put_byte(pb, 0xff);
559 }
560
561
562 /* flush the packet on stream stream_index */
563 static void flush_packet(AVFormatContext *ctx, int stream_index, 
564                          int64_t pts, int64_t dts, int64_t scr)
565 {
566     MpegMuxContext *s = ctx->priv_data;
567     StreamInfo *stream = ctx->streams[stream_index]->priv_data;
568     uint8_t *buf_ptr;
569     int size, payload_size, startcode, id, stuffing_size, i, header_len;
570     int packet_size;
571     uint8_t buffer[128];
572     int zero_trail_bytes = 0;
573     int pad_packet_bytes = 0;
574     int pes_flags;
575     int general_pack = 0;  /*"general" pack without data specific to one stream?*/
576     
577     id = stream->id;
578     
579 #if 0
580     printf("packet ID=%2x PTS=%0.3f\n", 
581            id, pts / 90000.0);
582 #endif
583
584     buf_ptr = buffer;
585
586     if (((s->packet_number % s->pack_header_freq) == 0)) {
587         /* output pack and systems header if needed */
588         size = put_pack_header(ctx, buf_ptr, scr);
589         buf_ptr += size;
590
591         if (s->is_vcd) {
592             /* there is exactly one system header for each stream in a VCD MPEG,
593                One in the very first video packet and one in the very first
594                audio packet (see VCD standard p. IV-7 and IV-8).*/
595             
596             if (stream->packet_number==0) {
597                 size = put_system_header(ctx, buf_ptr, id);
598                 buf_ptr += size;
599             }
600         } else {
601             if ((s->packet_number % s->system_header_freq) == 0) {
602                 size = put_system_header(ctx, buf_ptr, 0);
603                 buf_ptr += size;
604             }
605         }
606     }
607     size = buf_ptr - buffer;
608     put_buffer(&ctx->pb, buffer, size);
609
610     packet_size = s->packet_size - size;
611
612     if (s->is_vcd && id == AUDIO_ID)
613         /* The VCD standard demands that 20 zero bytes follow
614            each audio pack (see standard p. IV-8).*/
615         zero_trail_bytes += 20;
616             
617     if ((s->is_vcd && stream->packet_number==0)
618         || (s->is_svcd && s->packet_number==0)) {
619         /* for VCD the first pack of each stream contains only the pack header,
620            the system header and lots of padding (see VCD standard p. IV-6).
621            In the case of an audio pack, 20 zero bytes are also added at
622            the end.*/
623         /* For SVCD we fill the very first pack to increase compatibility with
624            some DVD players. Not mandated by the standard.*/
625         if (s->is_svcd)
626             general_pack = 1;    /* the system header refers to both streams and no stream data*/
627         pad_packet_bytes = packet_size - zero_trail_bytes;
628     }
629
630     packet_size -= pad_packet_bytes + zero_trail_bytes;
631
632     if (packet_size > 0) {
633
634         /* packet header size */
635         packet_size -= 6;
636         
637         /* packet header */
638         if (s->is_mpeg2) {
639             header_len = 3;
640             if (stream->packet_number==0)
641                 header_len += 3; /* PES extension */
642             header_len += 1; /* obligatory stuffing byte */
643         } else {
644             header_len = 0;
645         }
646         if (pts != AV_NOPTS_VALUE) {
647             if (dts != pts)
648                 header_len += 5 + 5;
649             else
650                 header_len += 5;
651         } else {
652             if (!s->is_mpeg2)
653                 header_len++;
654         }
655
656         payload_size = packet_size - header_len;
657         if (id < 0xc0) {
658             startcode = PRIVATE_STREAM_1;
659             payload_size -= 4;
660             if (id >= 0xa0)
661                 payload_size -= 3;
662         } else {
663             startcode = 0x100 + id;
664         }
665
666         stuffing_size = payload_size - stream->buffer_ptr;
667         if (stuffing_size < 0)
668             stuffing_size = 0;
669         if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
670             pad_packet_bytes += stuffing_size;
671             packet_size -= stuffing_size;
672             payload_size -= stuffing_size;
673             stuffing_size = 0;
674         }
675
676         put_be32(&ctx->pb, startcode);
677
678         put_be16(&ctx->pb, packet_size);
679         
680         if (!s->is_mpeg2)
681             for(i=0;i<stuffing_size;i++)
682                 put_byte(&ctx->pb, 0xff);
683
684         if (s->is_mpeg2) {
685             put_byte(&ctx->pb, 0x80); /* mpeg2 id */
686
687             pes_flags=0;
688
689             if (pts != AV_NOPTS_VALUE) {
690                 pes_flags |= 0x80;
691                 if (dts != pts)
692                     pes_flags |= 0x40;
693             }
694
695             /* Both the MPEG-2 and the SVCD standards demand that the
696                P-STD_buffer_size field be included in the first packet of
697                every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
698                and MPEG-2 standard 2.7.7) */
699             if (stream->packet_number == 0)
700                 pes_flags |= 0x01;
701
702             put_byte(&ctx->pb, pes_flags); /* flags */
703             put_byte(&ctx->pb, header_len - 3 + stuffing_size);
704
705             if (pes_flags & 0x80)  /*write pts*/
706                 put_timestamp(&ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
707             if (pes_flags & 0x40)  /*write dts*/
708                 put_timestamp(&ctx->pb, 0x01, dts);
709             
710             if (pes_flags & 0x01) {  /*write pes extension*/
711                 put_byte(&ctx->pb, 0x10); /* flags */
712
713                 /* P-STD buffer info */                
714                 if (id == AUDIO_ID)
715                     put_be16(&ctx->pb, 0x4000 | stream->max_buffer_size/128);
716                 else
717                     put_be16(&ctx->pb, 0x6000 | stream->max_buffer_size/1024);
718             }
719
720         } else {
721             if (pts != AV_NOPTS_VALUE) {
722                 if (dts != pts) {
723                     put_timestamp(&ctx->pb, 0x03, pts);
724                     put_timestamp(&ctx->pb, 0x01, dts);
725                 } else {
726                     put_timestamp(&ctx->pb, 0x02, pts);
727                 }
728             } else {
729                 put_byte(&ctx->pb, 0x0f);
730             }
731         }
732
733         if (startcode == PRIVATE_STREAM_1) {
734             put_byte(&ctx->pb, id);
735             if (id >= 0xa0) {
736                 /* LPCM (XXX: check nb_frames) */
737                 put_byte(&ctx->pb, 7);
738                 put_be16(&ctx->pb, 4); /* skip 3 header bytes */
739                 put_byte(&ctx->pb, stream->lpcm_header[0]);
740                 put_byte(&ctx->pb, stream->lpcm_header[1]);
741                 put_byte(&ctx->pb, stream->lpcm_header[2]);
742             } else {
743                 /* AC3 */
744                 put_byte(&ctx->pb, stream->nb_frames);
745                 put_be16(&ctx->pb, stream->frame_start_offset);
746             }
747         }
748
749         if (s->is_mpeg2) {
750             /* special stuffing byte that is always written
751                to prevent accidental generation of start codes. */
752             put_byte(&ctx->pb, 0xff);
753
754             for(i=0;i<stuffing_size;i++)
755                 put_byte(&ctx->pb, 0xff);
756         }
757
758         /* output data */
759         put_buffer(&ctx->pb, stream->buffer, payload_size - stuffing_size);
760     }
761
762     if (pad_packet_bytes > 0)
763         put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);    
764
765     for(i=0;i<zero_trail_bytes;i++)
766         put_byte(&ctx->pb, 0x00);
767         
768     put_flush_packet(&ctx->pb);
769     
770     s->packet_number++;
771
772     /* only increase the stream packet number if this pack actually contains
773        something that is specific to this stream! I.e. a dedicated header
774        or some data.*/
775     if (!general_pack)
776         stream->packet_number++;
777     stream->nb_frames = 0;
778     stream->frame_start_offset = 0;
779 }
780
781 static void put_vcd_padding_sector(AVFormatContext *ctx)
782 {
783     /* There are two ways to do this padding: writing a sector/pack
784        of 0 values, or writing an MPEG padding pack. Both seem to
785        work with most decoders, BUT the VCD standard only allows a 0-sector
786        (see standard p. IV-4, IV-5).
787        So a 0-sector it is...*/
788
789     MpegMuxContext *s = ctx->priv_data;
790     int i;
791
792     for(i=0;i<s->packet_size;i++)
793         put_byte(&ctx->pb, 0);
794
795     s->vcd_padding_bytes_written += s->packet_size;
796         
797     put_flush_packet(&ctx->pb);
798     
799     /* increasing the packet number is correct. The SCR of the following packs
800        is calculated from the packet_number and it has to include the padding
801        sector (it represents the sector index, not the MPEG pack index)
802        (see VCD standard p. IV-6)*/
803     s->packet_number++;
804 }
805
806 /* XXX: move that to upper layer */
807 /* XXX: we assume that there are always 'max_b_frames' between
808    reference frames. A better solution would be to use the AVFrame pts
809    field */
810 static void compute_pts_dts(AVStream *st, int64_t *ppts, int64_t *pdts, 
811                             int64_t timestamp)
812 {
813     int frame_delay;
814     int64_t pts, dts;
815
816     if (st->codec.codec_type == CODEC_TYPE_VIDEO && 
817         st->codec.max_b_frames != 0) {
818         frame_delay = (st->codec.frame_rate_base * 90000LL) / 
819             st->codec.frame_rate;
820         if (timestamp == 0) {
821             /* specific case for first frame : DTS just before */
822             pts = timestamp;
823             dts = timestamp - frame_delay;
824         } else {
825             timestamp -= frame_delay;
826             if (st->codec.coded_frame->pict_type == FF_B_TYPE) {
827                 /* B frames has identical pts/dts */
828                 pts = timestamp;
829                 dts = timestamp;
830             } else {
831                 /* a reference frame has a pts equal to the dts of the
832                    _next_ one */
833                 dts = timestamp;
834                 pts = timestamp + (st->codec.max_b_frames + 1) * frame_delay;
835             }
836         }
837 #if 1
838         av_log(&st->codec, AV_LOG_DEBUG, "pts=%0.3f dts=%0.3f pict_type=%c\n", 
839                pts / 90000.0, dts / 90000.0, 
840                av_get_pict_type_char(st->codec.coded_frame->pict_type));
841 #endif
842     } else {
843         pts = timestamp;
844         dts = timestamp;
845     }
846
847     *ppts = pts & ((1LL << 33) - 1);
848     *pdts = dts & ((1LL << 33) - 1);
849 }
850
851 static int64_t update_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
852 {
853     MpegMuxContext *s = ctx->priv_data;
854     int64_t scr;
855     StreamInfo *stream;
856     int i;
857
858     if (s->is_vcd) {
859         /* Since the data delivery rate is constant, SCR is computed
860            using the formula C + i * 1200 where C is the start constant
861            and i is the pack index.
862            It is recommended that SCR 0 is at the beginning of the VCD front
863            margin (a sequence of empty Form 2 sectors on the CD).
864            It is recommended that the front margin is 30 sectors long, so
865            we use C = 30*1200 = 36000
866            (Note that even if the front margin is not 30 sectors the file
867            will still be correct according to the standard. It just won't have
868            the "recommended" value).*/
869         scr = 36000 + s->packet_number * 1200;
870
871
872 #if 0
873         for(i=0;i<ctx->nb_streams;i++) {
874             stream = ctx->streams[i]->priv_data;
875             
876             if(scr > stream->start_pts && stream->start_pts!=AV_NOPTS_VALUE) {
877                 av_log(ctx, AV_LOG_DEBUG, "mpeg vcd: SCR above PTS (scr=%0.3f, stream index=%d, stream_pts=%0.3f).\n", scr/90000.0, i, stream->start_pts / 90000.0);                 
878             }
879         }
880 #endif
881     }
882     else {
883         
884         
885         /* XXX I believe this calculation of SCR is wrong. SCR
886            specifies at which time the data should enter the decoder.
887            Two packs cannot enter the decoder at the same time. */
888
889         /* XXX: system clock should be computed precisely, especially for
890         CBR case. The current mode gives at least something coherent */
891         if (stream_index == s->scr_stream_index
892             && pts != AV_NOPTS_VALUE)
893             scr = pts;
894         else
895             scr = s->last_scr;
896
897         /* "Sanity hack": make sure that the SCR does not overtake the pts of
898            buffered data that is still waiting to be written.*/
899         for(i=0;i<ctx->nb_streams;i++) {
900             stream = ctx->streams[i]->priv_data;
901             
902             if(scr > stream->start_pts && stream->start_pts!=AV_NOPTS_VALUE) {
903                 /* av_log(ctx, AV_LOG_DEBUG, "mpeg: restricting scr to stream pts (scr=%0.3f, stream index=%d, stream_pts=%0.3f).\n", scr/90000.0, i, stream->start_pts / 90000.0); */
904                 scr = stream->start_pts;
905             }
906         }
907     }
908
909     s->last_scr=scr;
910
911     return scr;
912 }    
913
914
915 static int mpeg_mux_write_packet(AVFormatContext *ctx, int stream_index,
916                                  const uint8_t *buf, int size, 
917                                  int64_t timestamp)
918 {
919     MpegMuxContext *s = ctx->priv_data;
920     AVStream *st = ctx->streams[stream_index];
921     StreamInfo *stream = st->priv_data;
922     int64_t pts, dts, new_start_pts, new_start_dts;
923     int len, avail_size;
924     
925     compute_pts_dts(st, &pts, &dts, timestamp);
926
927     if(s->is_svcd) {
928         /* offset pts and dts slightly into the future to be able
929            to do the compatibility fix below.*/
930         pts = (pts + 2) & ((1LL << 33) - 1);
931         dts = (dts + 2) & ((1LL << 33) - 1);
932
933         if (stream->packet_number == 0 && dts == pts)
934             /* For the very first packet we want to force the DTS to be included.
935                This increases compatibility with lots of DVD players.
936                Since the MPEG-2 standard mandates that DTS is only written when
937                it is different from PTS we have to move it slightly into the past.*/
938             dts = (dts - 2) & ((1LL << 33) - 1);
939     }
940     if(s->is_vcd) {
941         /* We have to offset the PTS, so that it is consistent with the SCR.
942            SCR starts at 36000, but the first two packs contain only padding
943            and the first pack from the other stream, respectively, may also have
944            been written before.
945            So the real data starts at SCR 36000+3*1200. */
946         pts = (pts + 36000 + 3600) & ((1LL << 33) - 1);
947         dts = (dts + 36000 + 3600) & ((1LL << 33) - 1);
948     }
949     
950 #if 0
951     update_scr(ctx,stream_index,pts);
952
953     printf("%d: pts=%0.3f dts=%0.3f scr=%0.3f\n", 
954            stream_index, 
955            pts / 90000.0, 
956            dts / 90000.0, 
957            s->last_scr / 90000.0);
958 #endif
959     
960     /* we assume here that pts != AV_NOPTS_VALUE */
961     new_start_pts = stream->start_pts;
962     new_start_dts = stream->start_dts;
963     
964     if (stream->start_pts == AV_NOPTS_VALUE) {
965         new_start_pts = pts;
966         new_start_dts = dts;
967     }
968     avail_size = get_packet_payload_size(ctx, stream_index,
969                                          new_start_pts, 
970                                          new_start_dts);
971     if (stream->buffer_ptr >= avail_size) {
972
973         update_scr(ctx,stream_index,stream->start_pts);
974
975         /* unlikely case: outputing the pts or dts increase the packet
976            size so that we cannot write the start of the next
977            packet. In this case, we must flush the current packet with
978            padding.
979            Note: this always happens for the first audio and video packet
980            in a VCD file, since they do not carry any data.*/
981         flush_packet(ctx, stream_index,
982                      stream->start_pts, stream->start_dts, s->last_scr);
983         stream->buffer_ptr = 0;
984     }
985     stream->start_pts = new_start_pts;
986     stream->start_dts = new_start_dts;
987     stream->nb_frames++;
988     if (stream->frame_start_offset == 0)
989         stream->frame_start_offset = stream->buffer_ptr;
990     while (size > 0) {
991         avail_size = get_packet_payload_size(ctx, stream_index,
992                                              stream->start_pts, 
993                                              stream->start_dts);
994         len = avail_size - stream->buffer_ptr;
995         if (len > size)
996             len = size;
997         memcpy(stream->buffer + stream->buffer_ptr, buf, len);
998         stream->buffer_ptr += len;
999         buf += len;
1000         size -= len;
1001         if (stream->buffer_ptr >= avail_size) {
1002
1003             update_scr(ctx,stream_index,stream->start_pts);
1004
1005             /* if packet full, we send it now */
1006             flush_packet(ctx, stream_index,
1007                          stream->start_pts, stream->start_dts, s->last_scr);
1008             stream->buffer_ptr = 0;
1009
1010             if (s->is_vcd) {
1011                 /* Write one or more padding sectors, if necessary, to reach
1012                    the constant overall bitrate.*/
1013                 int vcd_pad_bytes;
1014             
1015                 while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->start_pts) ) >= s->packet_size)
1016                     put_vcd_padding_sector(ctx);
1017             }
1018
1019             /* Make sure only the FIRST pes packet for this frame has
1020                a timestamp */
1021             stream->start_pts = AV_NOPTS_VALUE;
1022             stream->start_dts = AV_NOPTS_VALUE;
1023         }
1024     }
1025
1026     return 0;
1027 }
1028
1029 static int mpeg_mux_end(AVFormatContext *ctx)
1030 {
1031     MpegMuxContext *s = ctx->priv_data;
1032     StreamInfo *stream;
1033     int i;
1034
1035     /* flush each packet */
1036     for(i=0;i<ctx->nb_streams;i++) {
1037         stream = ctx->streams[i]->priv_data;
1038         if (stream->buffer_ptr > 0) {
1039             update_scr(ctx,i,stream->start_pts);
1040
1041             /* NOTE: we can always write the remaining data as it was
1042                tested before in mpeg_mux_write_packet() */
1043             flush_packet(ctx, i, stream->start_pts, stream->start_dts, 
1044                          s->last_scr);
1045         }
1046     }
1047
1048     /* End header according to MPEG1 systems standard. We do not write
1049        it as it is usually not needed by decoders and because it
1050        complicates MPEG stream concatenation. */
1051     //put_be32(&ctx->pb, ISO_11172_END_CODE);
1052     //put_flush_packet(&ctx->pb);
1053
1054     for(i=0;i<ctx->nb_streams;i++)
1055         av_freep(&ctx->streams[i]->priv_data);
1056
1057     return 0;
1058 }
1059 #endif //CONFIG_ENCODERS
1060
1061 /*********************************************/
1062 /* demux code */
1063
1064 #define MAX_SYNC_SIZE 100000
1065
1066 static int mpegps_probe(AVProbeData *p)
1067 {
1068     int code, c, i;
1069
1070     code = 0xff;
1071     /* we search the first start code. If it is a packet start code,
1072        then we decide it is mpeg ps. We do not send highest value to
1073        give a chance to mpegts */
1074     /* NOTE: the search range was restricted to avoid too many false
1075        detections */
1076
1077     if (p->buf_size < 6)
1078         return 0;
1079
1080     for (i = 0; i < 20; i++) {
1081         c = p->buf[i];
1082         code = (code << 8) | c;
1083         if ((code & 0xffffff00) == 0x100) {
1084             if (code == PACK_START_CODE ||
1085                 code == SYSTEM_HEADER_START_CODE ||
1086                 (code >= 0x1e0 && code <= 0x1ef) ||
1087                 (code >= 0x1c0 && code <= 0x1df) ||
1088                 code == PRIVATE_STREAM_2 ||
1089                 code == PROGRAM_STREAM_MAP ||
1090                 code == PRIVATE_STREAM_1 ||
1091                 code == PADDING_STREAM)
1092                 return AVPROBE_SCORE_MAX - 2;
1093             else
1094                 return 0;
1095         }
1096     }
1097     return 0;
1098 }
1099
1100
1101 typedef struct MpegDemuxContext {
1102     int header_state;
1103 } MpegDemuxContext;
1104
1105 static int mpegps_read_header(AVFormatContext *s,
1106                               AVFormatParameters *ap)
1107 {
1108     MpegDemuxContext *m = s->priv_data;
1109     m->header_state = 0xff;
1110     s->ctx_flags |= AVFMTCTX_NOHEADER;
1111
1112     /* no need to do more */
1113     return 0;
1114 }
1115
1116 static int64_t get_pts(ByteIOContext *pb, int c)
1117 {
1118     int64_t pts;
1119     int val;
1120
1121     if (c < 0)
1122         c = get_byte(pb);
1123     pts = (int64_t)((c >> 1) & 0x07) << 30;
1124     val = get_be16(pb);
1125     pts |= (int64_t)(val >> 1) << 15;
1126     val = get_be16(pb);
1127     pts |= (int64_t)(val >> 1);
1128     return pts;
1129 }
1130
1131 static int find_next_start_code(ByteIOContext *pb, int *size_ptr, 
1132                                 uint32_t *header_state)
1133 {
1134     unsigned int state, v;
1135     int val, n;
1136
1137     state = *header_state;
1138     n = *size_ptr;
1139     while (n > 0) {
1140         if (url_feof(pb))
1141             break;
1142         v = get_byte(pb);
1143         n--;
1144         if (state == 0x000001) {
1145             state = ((state << 8) | v) & 0xffffff;
1146             val = state;
1147             goto found;
1148         }
1149         state = ((state << 8) | v) & 0xffffff;
1150     }
1151     val = -1;
1152  found:
1153     *header_state = state;
1154     *size_ptr = n;
1155     return val;
1156 }
1157
1158 /* XXX: optimize */
1159 static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1160 {
1161     int64_t pos, pos_start;
1162     int max_size, start_code;
1163
1164     max_size = *size_ptr;
1165     pos_start = url_ftell(pb);
1166
1167     /* in order to go faster, we fill the buffer */
1168     pos = pos_start - 16386;
1169     if (pos < 0)
1170         pos = 0;
1171     url_fseek(pb, pos, SEEK_SET);
1172     get_byte(pb);
1173
1174     pos = pos_start;
1175     for(;;) {
1176         pos--;
1177         if (pos < 0 || (pos_start - pos) >= max_size) {
1178             start_code = -1;
1179             goto the_end;
1180         }
1181         url_fseek(pb, pos, SEEK_SET);
1182         start_code = get_be32(pb);
1183         if ((start_code & 0xffffff00) == 0x100)
1184             break;
1185     }
1186  the_end:
1187     *size_ptr = pos_start - pos;
1188     return start_code;
1189 }
1190
1191 /* read the next PES header. Return its position in ppos 
1192    (if not NULL), and its start code, pts and dts.
1193  */
1194 static int mpegps_read_pes_header(AVFormatContext *s,
1195                                   int64_t *ppos, int *pstart_code, 
1196                                   int64_t *ppts, int64_t *pdts)
1197 {
1198     MpegDemuxContext *m = s->priv_data;
1199     int len, size, startcode, c, flags, header_len;
1200     int64_t pts, dts, last_pos;
1201
1202     last_pos = -1;
1203  redo:
1204         /* next start code (should be immediately after) */
1205         m->header_state = 0xff;
1206         size = MAX_SYNC_SIZE;
1207         startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1208     //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
1209     if (startcode < 0)
1210         return -EIO;
1211     if (startcode == PACK_START_CODE)
1212         goto redo;
1213     if (startcode == SYSTEM_HEADER_START_CODE)
1214         goto redo;
1215     if (startcode == PADDING_STREAM ||
1216         startcode == PRIVATE_STREAM_2) {
1217         /* skip them */
1218         len = get_be16(&s->pb);
1219         url_fskip(&s->pb, len);
1220         goto redo;
1221     }
1222     /* find matching stream */
1223     if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1224           (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1225           (startcode == 0x1bd)))
1226         goto redo;
1227     if (ppos) {
1228         *ppos = url_ftell(&s->pb) - 4;
1229     }
1230     len = get_be16(&s->pb);
1231     pts = AV_NOPTS_VALUE;
1232     dts = AV_NOPTS_VALUE;
1233     /* stuffing */
1234     for(;;) {
1235         if (len < 1)
1236             goto redo;
1237         c = get_byte(&s->pb);
1238         len--;
1239         /* XXX: for mpeg1, should test only bit 7 */
1240         if (c != 0xff) 
1241             break;
1242     }
1243     if ((c & 0xc0) == 0x40) {
1244         /* buffer scale & size */
1245         if (len < 2)
1246             goto redo;
1247         get_byte(&s->pb);
1248         c = get_byte(&s->pb);
1249         len -= 2;
1250     }
1251     if ((c & 0xf0) == 0x20) {
1252         if (len < 4)
1253             goto redo;
1254         dts = pts = get_pts(&s->pb, c);
1255         len -= 4;
1256     } else if ((c & 0xf0) == 0x30) {
1257         if (len < 9)
1258             goto redo;
1259         pts = get_pts(&s->pb, c);
1260         dts = get_pts(&s->pb, -1);
1261         len -= 9;
1262     } else if ((c & 0xc0) == 0x80) {
1263         /* mpeg 2 PES */
1264         if ((c & 0x30) != 0) {
1265             /* Encrypted multiplex not handled */
1266             goto redo;
1267         }
1268         flags = get_byte(&s->pb);
1269         header_len = get_byte(&s->pb);
1270         len -= 2;
1271         if (header_len > len)
1272             goto redo;
1273         if ((flags & 0xc0) == 0x80) {
1274             dts = pts = get_pts(&s->pb, -1);
1275             if (header_len < 5)
1276                 goto redo;
1277             header_len -= 5;
1278             len -= 5;
1279         } if ((flags & 0xc0) == 0xc0) {
1280             pts = get_pts(&s->pb, -1);
1281             dts = get_pts(&s->pb, -1);
1282             if (header_len < 10)
1283                 goto redo;
1284             header_len -= 10;
1285             len -= 10;
1286         }
1287         len -= header_len;
1288         while (header_len > 0) {
1289             get_byte(&s->pb);
1290             header_len--;
1291         }
1292     }
1293     else if( c!= 0xf )
1294         goto redo;
1295
1296     if (startcode == 0x1bd) {
1297         if (len < 1)
1298             goto redo;
1299         startcode = get_byte(&s->pb);
1300         len--;
1301         if (startcode >= 0x80 && startcode <= 0xbf) {
1302             /* audio: skip header */
1303             if (len < 3)
1304                 goto redo;
1305             get_byte(&s->pb);
1306             get_byte(&s->pb);
1307             get_byte(&s->pb);
1308             len -= 3;
1309         }
1310     }
1311     if(dts != AV_NOPTS_VALUE && ppos){
1312         int i;
1313         for(i=0; i<s->nb_streams; i++){
1314             if(startcode == s->streams[i]->id) {
1315                 av_add_index_entry(s->streams[i], *ppos, dts*AV_TIME_BASE/90000, 0, 0 /* FIXME keyframe? */);
1316             }
1317         }
1318     }
1319     
1320     *pstart_code = startcode;
1321     *ppts = pts;
1322     *pdts = dts;
1323     return len;
1324 }
1325
1326 static int mpegps_read_packet(AVFormatContext *s,
1327                               AVPacket *pkt)
1328 {
1329     AVStream *st;
1330     int len, startcode, i, type, codec_id;
1331     int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1332
1333  redo:
1334     len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1335     if (len < 0)
1336         return len;
1337     
1338     /* now find stream */
1339     for(i=0;i<s->nb_streams;i++) {
1340         st = s->streams[i];
1341         if (st->id == startcode)
1342             goto found;
1343     }
1344     if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1345         type = CODEC_TYPE_VIDEO;
1346         codec_id = CODEC_ID_MPEG2VIDEO;
1347     } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1348         type = CODEC_TYPE_AUDIO;
1349         codec_id = CODEC_ID_MP2;
1350     } else if (startcode >= 0x80 && startcode <= 0x9f) {
1351         type = CODEC_TYPE_AUDIO;
1352         codec_id = CODEC_ID_AC3;
1353     } else if (startcode >= 0xa0 && startcode <= 0xbf) {
1354         type = CODEC_TYPE_AUDIO;
1355         codec_id = CODEC_ID_PCM_S16BE;
1356     } else {
1357     skip:
1358         /* skip packet */
1359         url_fskip(&s->pb, len);
1360         goto redo;
1361     }
1362     /* no stream found: add a new stream */
1363     st = av_new_stream(s, startcode);
1364     if (!st) 
1365         goto skip;
1366     st->codec.codec_type = type;
1367     st->codec.codec_id = codec_id;
1368     if (codec_id != CODEC_ID_PCM_S16BE)
1369         st->need_parsing = 1;
1370  found:
1371     if (startcode >= 0xa0 && startcode <= 0xbf) {
1372         int b1, freq;
1373
1374         /* for LPCM, we just skip the header and consider it is raw
1375            audio data */
1376         if (len <= 3)
1377             goto skip;
1378         get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1379         b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1380         get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1381         len -= 3;
1382         freq = (b1 >> 4) & 3;
1383         st->codec.sample_rate = lpcm_freq_tab[freq];
1384         st->codec.channels = 1 + (b1 & 7);
1385         st->codec.bit_rate = st->codec.channels * st->codec.sample_rate * 2;
1386     }
1387     av_new_packet(pkt, len);
1388     get_buffer(&s->pb, pkt->data, pkt->size);
1389     pkt->pts = pts;
1390     pkt->dts = dts;
1391     pkt->stream_index = st->index;
1392 #if 0
1393     printf("%d: pts=%0.3f dts=%0.3f\n",
1394            pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0);
1395 #endif
1396     return 0;
1397 }
1398
1399 static int mpegps_read_close(AVFormatContext *s)
1400 {
1401     return 0;
1402 }
1403
1404 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, 
1405                                int64_t *ppos, int64_t pos_limit)
1406 {
1407     int len, startcode;
1408     int64_t pos, pts, dts;
1409
1410     pos = *ppos;
1411 #ifdef DEBUG_SEEK
1412     printf("read_dts: pos=0x%llx next=%d -> ", pos, find_next);
1413 #endif
1414     url_fseek(&s->pb, pos, SEEK_SET);
1415     for(;;) {
1416         len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1417         if (len < 0) {
1418 #ifdef DEBUG_SEEK
1419             printf("none (ret=%d)\n", len);
1420 #endif
1421             return AV_NOPTS_VALUE;
1422         }
1423         if (startcode == s->streams[stream_index]->id && 
1424             dts != AV_NOPTS_VALUE) {
1425             break;
1426         }
1427         url_fskip(&s->pb, len);
1428     }
1429 #ifdef DEBUG_SEEK
1430     printf("pos=0x%llx dts=0x%llx %0.3f\n", pos, dts, dts / 90000.0);
1431 #endif
1432     *ppos = pos;
1433     return dts*AV_TIME_BASE/90000;
1434 }
1435
1436 #ifdef CONFIG_ENCODERS
1437 static AVOutputFormat mpeg1system_mux = {
1438     "mpeg",
1439     "MPEG1 System format",
1440     "video/mpeg",
1441     "mpg,mpeg",
1442     sizeof(MpegMuxContext),
1443     CODEC_ID_MP2,
1444     CODEC_ID_MPEG1VIDEO,
1445     mpeg_mux_init,
1446     mpeg_mux_write_packet,
1447     mpeg_mux_end,
1448 };
1449
1450 static AVOutputFormat mpeg1vcd_mux = {
1451     "vcd",
1452     "MPEG1 System format (VCD)",
1453     "video/mpeg",
1454     NULL,
1455     sizeof(MpegMuxContext),
1456     CODEC_ID_MP2,
1457     CODEC_ID_MPEG1VIDEO,
1458     mpeg_mux_init,
1459     mpeg_mux_write_packet,
1460     mpeg_mux_end,
1461 };
1462
1463 static AVOutputFormat mpeg2vob_mux = {
1464     "vob",
1465     "MPEG2 PS format (VOB)",
1466     "video/mpeg",
1467     "vob",
1468     sizeof(MpegMuxContext),
1469     CODEC_ID_MP2,
1470     CODEC_ID_MPEG2VIDEO,
1471     mpeg_mux_init,
1472     mpeg_mux_write_packet,
1473     mpeg_mux_end,
1474 };
1475
1476 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1477 static AVOutputFormat mpeg2svcd_mux = {
1478     "svcd",
1479     "MPEG2 PS format (VOB)",
1480     "video/mpeg",
1481     "vob",
1482     sizeof(MpegMuxContext),
1483     CODEC_ID_MP2,
1484     CODEC_ID_MPEG2VIDEO,
1485     mpeg_mux_init,
1486     mpeg_mux_write_packet,
1487     mpeg_mux_end,
1488 };
1489
1490
1491
1492 #endif //CONFIG_ENCODERS
1493
1494 AVInputFormat mpegps_demux = {
1495     "mpeg",
1496     "MPEG PS format",
1497     sizeof(MpegDemuxContext),
1498     mpegps_probe,
1499     mpegps_read_header,
1500     mpegps_read_packet,
1501     mpegps_read_close,
1502     NULL, //mpegps_read_seek,
1503     mpegps_read_dts,
1504 };
1505
1506 int mpegps_init(void)
1507 {
1508 #ifdef CONFIG_ENCODERS
1509     av_register_output_format(&mpeg1system_mux);
1510     av_register_output_format(&mpeg1vcd_mux);
1511     av_register_output_format(&mpeg2vob_mux);
1512     av_register_output_format(&mpeg2svcd_mux);
1513 #endif //CONFIG_ENCODERS
1514     av_register_input_format(&mpegps_demux);
1515     return 0;
1516 }