add an enum for need_parsing
[ffmpeg.git] / libavformat / mpeg.c
1 /*
2  * MPEG1/2 muxer and demuxer
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 #include "avformat.h"
22 #include "bitstream.h"
23 #include "fifo.h"
24
25 #define MAX_PAYLOAD_SIZE 4096
26 //#define DEBUG_SEEK
27
28 #undef NDEBUG
29 #include <assert.h>
30
31 typedef struct PacketDesc {
32     int64_t pts;
33     int64_t dts;
34     int size;
35     int unwritten_size;
36     int flags;
37     struct PacketDesc *next;
38 } PacketDesc;
39
40 typedef struct {
41     AVFifoBuffer fifo;
42     uint8_t id;
43     int max_buffer_size; /* in bytes */
44     int buffer_index;
45     PacketDesc *predecode_packet;
46     PacketDesc *premux_packet;
47     PacketDesc **next_packet;
48     int packet_number;
49     uint8_t lpcm_header[3];
50     int lpcm_align;
51     int bytes_to_iframe;
52     int align_iframe;
53     int64_t vobu_start_pts;
54 } StreamInfo;
55
56 typedef struct {
57     int packet_size; /* required packet size */
58     int packet_number;
59     int pack_header_freq;     /* frequency (in packets^-1) at which we send pack headers */
60     int system_header_freq;
61     int system_header_size;
62     int mux_rate; /* bitrate in units of 50 bytes/s */
63     /* stream info */
64     int audio_bound;
65     int video_bound;
66     int is_mpeg2;
67     int is_vcd;
68     int is_svcd;
69     int is_dvd;
70     int64_t last_scr; /* current system clock */
71
72     double vcd_padding_bitrate; //FIXME floats
73     int64_t vcd_padding_bytes_written;
74
75 } MpegMuxContext;
76
77 #define PACK_START_CODE             ((unsigned int)0x000001ba)
78 #define SYSTEM_HEADER_START_CODE    ((unsigned int)0x000001bb)
79 #define SEQUENCE_END_CODE           ((unsigned int)0x000001b7)
80 #define PACKET_START_CODE_MASK      ((unsigned int)0xffffff00)
81 #define PACKET_START_CODE_PREFIX    ((unsigned int)0x00000100)
82 #define ISO_11172_END_CODE          ((unsigned int)0x000001b9)
83
84 /* mpeg2 */
85 #define PROGRAM_STREAM_MAP 0x1bc
86 #define PRIVATE_STREAM_1   0x1bd
87 #define PADDING_STREAM     0x1be
88 #define PRIVATE_STREAM_2   0x1bf
89
90
91 #define AUDIO_ID 0xc0
92 #define VIDEO_ID 0xe0
93 #define AC3_ID   0x80
94 #define DTS_ID   0x8a
95 #define LPCM_ID  0xa0
96 #define SUB_ID   0x20
97
98 #define STREAM_TYPE_VIDEO_MPEG1     0x01
99 #define STREAM_TYPE_VIDEO_MPEG2     0x02
100 #define STREAM_TYPE_AUDIO_MPEG1     0x03
101 #define STREAM_TYPE_AUDIO_MPEG2     0x04
102 #define STREAM_TYPE_PRIVATE_SECTION 0x05
103 #define STREAM_TYPE_PRIVATE_DATA    0x06
104 #define STREAM_TYPE_AUDIO_AAC       0x0f
105 #define STREAM_TYPE_VIDEO_MPEG4     0x10
106 #define STREAM_TYPE_VIDEO_H264      0x1b
107
108 #define STREAM_TYPE_AUDIO_AC3       0x81
109 #define STREAM_TYPE_AUDIO_DTS       0x8a
110
111 static const int lpcm_freq_tab[4] = { 48000, 96000, 44100, 32000 };
112
113 #ifdef CONFIG_MUXERS
114 AVOutputFormat mpeg1system_muxer;
115 AVOutputFormat mpeg1vcd_muxer;
116 AVOutputFormat mpeg2vob_muxer;
117 AVOutputFormat mpeg2svcd_muxer;
118 AVOutputFormat mpeg2dvd_muxer;
119
120 static int put_pack_header(AVFormatContext *ctx,
121                            uint8_t *buf, int64_t timestamp)
122 {
123     MpegMuxContext *s = ctx->priv_data;
124     PutBitContext pb;
125
126     init_put_bits(&pb, buf, 128);
127
128     put_bits(&pb, 32, PACK_START_CODE);
129     if (s->is_mpeg2) {
130         put_bits(&pb, 2, 0x1);
131     } else {
132         put_bits(&pb, 4, 0x2);
133     }
134     put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
135     put_bits(&pb, 1, 1);
136     put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
137     put_bits(&pb, 1, 1);
138     put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
139     put_bits(&pb, 1, 1);
140     if (s->is_mpeg2) {
141         /* clock extension */
142         put_bits(&pb, 9, 0);
143     }
144     put_bits(&pb, 1, 1);
145     put_bits(&pb, 22, s->mux_rate);
146     put_bits(&pb, 1, 1);
147     if (s->is_mpeg2) {
148         put_bits(&pb, 1, 1);
149         put_bits(&pb, 5, 0x1f); /* reserved */
150         put_bits(&pb, 3, 0); /* stuffing length */
151     }
152     flush_put_bits(&pb);
153     return pbBufPtr(&pb) - pb.buf;
154 }
155
156 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
157 {
158     MpegMuxContext *s = ctx->priv_data;
159     int size, i, private_stream_coded, id;
160     PutBitContext pb;
161
162     init_put_bits(&pb, buf, 128);
163
164     put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
165     put_bits(&pb, 16, 0);
166     put_bits(&pb, 1, 1);
167
168     put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
169     put_bits(&pb, 1, 1); /* marker */
170     if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
171         /* This header applies only to the video stream (see VCD standard p. IV-7)*/
172         put_bits(&pb, 6, 0);
173     } else
174         put_bits(&pb, 6, s->audio_bound);
175
176     if (s->is_vcd) {
177         /* see VCD standard, p. IV-7*/
178         put_bits(&pb, 1, 0);
179         put_bits(&pb, 1, 1);
180     } else {
181         put_bits(&pb, 1, 0); /* variable bitrate*/
182         put_bits(&pb, 1, 0); /* non constrainted bit stream */
183     }
184
185     if (s->is_vcd || s->is_dvd) {
186         /* see VCD standard p IV-7 */
187         put_bits(&pb, 1, 1); /* audio locked */
188         put_bits(&pb, 1, 1); /* video locked */
189     } else {
190         put_bits(&pb, 1, 0); /* audio locked */
191         put_bits(&pb, 1, 0); /* video locked */
192     }
193
194     put_bits(&pb, 1, 1); /* marker */
195
196     if (s->is_vcd && only_for_stream_id==AUDIO_ID) {
197         /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
198         put_bits(&pb, 5, 0);
199     } else
200         put_bits(&pb, 5, s->video_bound);
201
202     if (s->is_dvd) {
203         put_bits(&pb, 1, 0);    /* packet_rate_restriction_flag */
204         put_bits(&pb, 7, 0x7f); /* reserved byte */
205     } else
206         put_bits(&pb, 8, 0xff); /* reserved byte */
207
208     /* DVD-Video Stream_bound entries
209     id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
210     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)
211     id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
212     id (0xBF) private stream 2, NAV packs, set to 2x1024. */
213     if (s->is_dvd) {
214
215         int P_STD_max_video = 0;
216         int P_STD_max_mpeg_audio = 0;
217         int P_STD_max_mpeg_PS1 = 0;
218
219         for(i=0;i<ctx->nb_streams;i++) {
220             StreamInfo *stream = ctx->streams[i]->priv_data;
221
222             id = stream->id;
223             if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
224                 P_STD_max_mpeg_PS1 = stream->max_buffer_size;
225             } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) {
226                 P_STD_max_mpeg_audio = stream->max_buffer_size;
227             } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) {
228                 P_STD_max_video = stream->max_buffer_size;
229             }
230         }
231
232         /* video */
233         put_bits(&pb, 8, 0xb9); /* stream ID */
234         put_bits(&pb, 2, 3);
235         put_bits(&pb, 1, 1);
236         put_bits(&pb, 13, P_STD_max_video / 1024);
237
238         /* audio */
239         if (P_STD_max_mpeg_audio == 0)
240             P_STD_max_mpeg_audio = 4096;
241         put_bits(&pb, 8, 0xb8); /* stream ID */
242         put_bits(&pb, 2, 3);
243         put_bits(&pb, 1, 0);
244         put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
245
246         /* private stream 1 */
247         put_bits(&pb, 8, 0xbd); /* stream ID */
248         put_bits(&pb, 2, 3);
249         put_bits(&pb, 1, 0);
250         put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
251
252         /* private stream 2 */
253         put_bits(&pb, 8, 0xbf); /* stream ID */
254         put_bits(&pb, 2, 3);
255         put_bits(&pb, 1, 1);
256         put_bits(&pb, 13, 2);
257     }
258     else {
259         /* audio stream info */
260         private_stream_coded = 0;
261         for(i=0;i<ctx->nb_streams;i++) {
262             StreamInfo *stream = ctx->streams[i]->priv_data;
263
264
265             /* For VCDs, only include the stream info for the stream
266             that the pack which contains this system belongs to.
267             (see VCD standard p. IV-7) */
268             if ( !s->is_vcd || stream->id==only_for_stream_id
269                 || only_for_stream_id==0) {
270
271                 id = stream->id;
272                 if (id < 0xc0) {
273                     /* special case for private streams (AC3 use that) */
274                     if (private_stream_coded)
275                         continue;
276                     private_stream_coded = 1;
277                     id = 0xbd;
278                 }
279                 put_bits(&pb, 8, id); /* stream ID */
280                 put_bits(&pb, 2, 3);
281                 if (id < 0xe0) {
282                     /* audio */
283                     put_bits(&pb, 1, 0);
284                     put_bits(&pb, 13, stream->max_buffer_size / 128);
285                 } else {
286                     /* video */
287                     put_bits(&pb, 1, 1);
288                     put_bits(&pb, 13, stream->max_buffer_size / 1024);
289                 }
290             }
291         }
292     }
293
294     flush_put_bits(&pb);
295     size = pbBufPtr(&pb) - pb.buf;
296     /* patch packet size */
297     buf[4] = (size - 6) >> 8;
298     buf[5] = (size - 6) & 0xff;
299
300     return size;
301 }
302
303 static int get_system_header_size(AVFormatContext *ctx)
304 {
305     int buf_index, i, private_stream_coded;
306     StreamInfo *stream;
307     MpegMuxContext *s = ctx->priv_data;
308
309     if (s->is_dvd)
310        return 18; // DVD-Video system headers are 18 bytes fixed length.
311
312     buf_index = 12;
313     private_stream_coded = 0;
314     for(i=0;i<ctx->nb_streams;i++) {
315         stream = ctx->streams[i]->priv_data;
316         if (stream->id < 0xc0) {
317             if (private_stream_coded)
318                 continue;
319             private_stream_coded = 1;
320         }
321         buf_index += 3;
322     }
323     return buf_index;
324 }
325
326 static int mpeg_mux_init(AVFormatContext *ctx)
327 {
328     MpegMuxContext *s = ctx->priv_data;
329     int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
330     AVStream *st;
331     StreamInfo *stream;
332     int audio_bitrate;
333     int video_bitrate;
334
335     s->packet_number = 0;
336     s->is_vcd = (ctx->oformat == &mpeg1vcd_muxer);
337     s->is_svcd = (ctx->oformat == &mpeg2svcd_muxer);
338     s->is_mpeg2 = (ctx->oformat == &mpeg2vob_muxer || ctx->oformat == &mpeg2svcd_muxer || ctx->oformat == &mpeg2dvd_muxer);
339     s->is_dvd = (ctx->oformat == &mpeg2dvd_muxer);
340
341     if(ctx->packet_size)
342         s->packet_size = ctx->packet_size;
343     else
344         s->packet_size = 2048;
345
346     s->vcd_padding_bytes_written = 0;
347     s->vcd_padding_bitrate=0;
348
349     s->audio_bound = 0;
350     s->video_bound = 0;
351     mpa_id = AUDIO_ID;
352     ac3_id = AC3_ID;
353     dts_id = DTS_ID;
354     mpv_id = VIDEO_ID;
355     mps_id = SUB_ID;
356     lpcm_id = LPCM_ID;
357     for(i=0;i<ctx->nb_streams;i++) {
358         st = ctx->streams[i];
359         stream = av_mallocz(sizeof(StreamInfo));
360         if (!stream)
361             goto fail;
362         st->priv_data = stream;
363
364         av_set_pts_info(st, 64, 1, 90000);
365
366         switch(st->codec->codec_type) {
367         case CODEC_TYPE_AUDIO:
368             if (st->codec->codec_id == CODEC_ID_AC3) {
369                 stream->id = ac3_id++;
370             } else if (st->codec->codec_id == CODEC_ID_DTS) {
371                 stream->id = dts_id++;
372             } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
373                 stream->id = lpcm_id++;
374                 for(j = 0; j < 4; j++) {
375                     if (lpcm_freq_tab[j] == st->codec->sample_rate)
376                         break;
377                 }
378                 if (j == 4)
379                     goto fail;
380                 if (st->codec->channels > 8)
381                     return -1;
382                 stream->lpcm_header[0] = 0x0c;
383                 stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
384                 stream->lpcm_header[2] = 0x80;
385                 stream->lpcm_align = st->codec->channels * 2;
386             } else {
387                 stream->id = mpa_id++;
388             }
389
390             /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
391                Right now it is also used for everything else.*/
392             stream->max_buffer_size = 4 * 1024;
393             s->audio_bound++;
394             break;
395         case CODEC_TYPE_VIDEO:
396             stream->id = mpv_id++;
397             if (st->codec->rc_buffer_size)
398                 stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
399             else
400                 stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
401 #if 0
402                 /* see VCD standard, p. IV-7*/
403                 stream->max_buffer_size = 46 * 1024;
404             else
405                 /* This value HAS to be used for SVCD (see SVCD standard, p. 26 V.2.3.2).
406                    Right now it is also used for everything else.*/
407                 stream->max_buffer_size = 230 * 1024;
408 #endif
409             s->video_bound++;
410             break;
411         case CODEC_TYPE_SUBTITLE:
412             stream->id = mps_id++;
413             stream->max_buffer_size = 16 * 1024;
414             break;
415         default:
416             return -1;
417         }
418         av_fifo_init(&stream->fifo, 16);
419     }
420     bitrate = 0;
421     audio_bitrate = 0;
422     video_bitrate = 0;
423     for(i=0;i<ctx->nb_streams;i++) {
424         int codec_rate;
425         st = ctx->streams[i];
426         stream = (StreamInfo*) st->priv_data;
427
428         if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
429             codec_rate= st->codec->rc_max_rate;
430         else
431             codec_rate= st->codec->bit_rate;
432
433         if(!codec_rate)
434             codec_rate= (1<<21)*8*50/ctx->nb_streams;
435
436         bitrate += codec_rate;
437
438         if (stream->id==AUDIO_ID)
439             audio_bitrate += codec_rate;
440         else if (stream->id==VIDEO_ID)
441             video_bitrate += codec_rate;
442     }
443
444     if(ctx->mux_rate){
445         s->mux_rate= (ctx->mux_rate + (8 * 50) - 1) / (8 * 50);
446     } else {
447         /* we increase slightly the bitrate to take into account the
448            headers. XXX: compute it exactly */
449         bitrate += bitrate*5/100;
450         bitrate += 10000;
451         s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
452     }
453
454     if (s->is_vcd) {
455         double overhead_rate;
456
457         /* The VCD standard mandates that the mux_rate field is 3528
458            (see standard p. IV-6).
459            The value is actually "wrong", i.e. if you calculate
460            it using the normal formula and the 75 sectors per second transfer
461            rate you get a different value because the real pack size is 2324,
462            not 2352. But the standard explicitly specifies that the mux_rate
463            field in the header must have this value.*/
464 //        s->mux_rate=2352 * 75 / 50;    /* = 3528*/
465
466         /* The VCD standard states that the muxed stream must be
467            exactly 75 packs / second (the data rate of a single speed cdrom).
468            Since the video bitrate (probably 1150000 bits/sec) will be below
469            the theoretical maximum we have to add some padding packets
470            to make up for the lower data rate.
471            (cf. VCD standard p. IV-6 )*/
472
473         /* Add the header overhead to the data rate.
474            2279 data bytes per audio pack, 2294 data bytes per video pack*/
475         overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
476         overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
477         overhead_rate *= 8;
478
479         /* Add padding so that the full bitrate is 2324*75 bytes/sec */
480         s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
481     }
482
483     if (s->is_vcd || s->is_mpeg2)
484         /* every packet */
485         s->pack_header_freq = 1;
486     else
487         /* every 2 seconds */
488         s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
489
490     /* the above seems to make pack_header_freq zero sometimes */
491     if (s->pack_header_freq == 0)
492        s->pack_header_freq = 1;
493
494     if (s->is_mpeg2)
495         /* every 200 packets. Need to look at the spec.  */
496         s->system_header_freq = s->pack_header_freq * 40;
497     else if (s->is_vcd)
498         /* the standard mandates that there are only two system headers
499            in the whole file: one in the first packet of each stream.
500            (see standard p. IV-7 and IV-8) */
501         s->system_header_freq = 0x7fffffff;
502     else
503         s->system_header_freq = s->pack_header_freq * 5;
504
505     for(i=0;i<ctx->nb_streams;i++) {
506         stream = ctx->streams[i]->priv_data;
507         stream->packet_number = 0;
508     }
509     s->system_header_size = get_system_header_size(ctx);
510     s->last_scr = 0;
511     return 0;
512  fail:
513     for(i=0;i<ctx->nb_streams;i++) {
514         av_free(ctx->streams[i]->priv_data);
515     }
516     return AVERROR(ENOMEM);
517 }
518
519 static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
520 {
521     put_byte(pb,
522              (id << 4) |
523              (((timestamp >> 30) & 0x07) << 1) |
524              1);
525     put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
526     put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
527 }
528
529
530 /* return the number of padding bytes that should be inserted into
531    the multiplexed stream.*/
532 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
533 {
534     MpegMuxContext *s = ctx->priv_data;
535     int pad_bytes = 0;
536
537     if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
538     {
539         int64_t full_pad_bytes;
540
541         full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
542         pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
543
544         if (pad_bytes<0)
545             /* might happen if we have already padded to a later timestamp. This
546                can occur if another stream has already advanced further.*/
547             pad_bytes=0;
548     }
549
550     return pad_bytes;
551 }
552
553
554 #if 0 /* unused, remove? */
555 /* return the exact available payload size for the next packet for
556    stream 'stream_index'. 'pts' and 'dts' are only used to know if
557    timestamps are needed in the packet header. */
558 static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
559                                    int64_t pts, int64_t dts)
560 {
561     MpegMuxContext *s = ctx->priv_data;
562     int buf_index;
563     StreamInfo *stream;
564
565     stream = ctx->streams[stream_index]->priv_data;
566
567     buf_index = 0;
568     if (((s->packet_number % s->pack_header_freq) == 0)) {
569         /* pack header size */
570         if (s->is_mpeg2)
571             buf_index += 14;
572         else
573             buf_index += 12;
574
575         if (s->is_vcd) {
576             /* there is exactly one system header for each stream in a VCD MPEG,
577                One in the very first video packet and one in the very first
578                audio packet (see VCD standard p. IV-7 and IV-8).*/
579
580             if (stream->packet_number==0)
581                 /* The system headers refer only to the stream they occur in,
582                    so they have a constant size.*/
583                 buf_index += 15;
584
585         } else {
586             if ((s->packet_number % s->system_header_freq) == 0)
587                 buf_index += s->system_header_size;
588         }
589     }
590
591     if ((s->is_vcd && stream->packet_number==0)
592         || (s->is_svcd && s->packet_number==0))
593         /* the first pack of each stream contains only the pack header,
594            the system header and some padding (see VCD standard p. IV-6)
595            Add the padding size, so that the actual payload becomes 0.*/
596         buf_index += s->packet_size - buf_index;
597     else {
598         /* packet header size */
599         buf_index += 6;
600         if (s->is_mpeg2) {
601             buf_index += 3;
602             if (stream->packet_number==0)
603                 buf_index += 3; /* PES extension */
604             buf_index += 1;    /* obligatory stuffing byte */
605         }
606         if (pts != AV_NOPTS_VALUE) {
607             if (dts != pts)
608                 buf_index += 5 + 5;
609             else
610                 buf_index += 5;
611
612         } else {
613             if (!s->is_mpeg2)
614                 buf_index++;
615         }
616
617         if (stream->id < 0xc0) {
618             /* AC3/LPCM private data header */
619             buf_index += 4;
620             if (stream->id >= 0xa0) {
621                 int n;
622                 buf_index += 3;
623                 /* NOTE: we round the payload size to an integer number of
624                    LPCM samples */
625                 n = (s->packet_size - buf_index) % stream->lpcm_align;
626                 if (n)
627                     buf_index += (stream->lpcm_align - n);
628             }
629         }
630
631         if (s->is_vcd && stream->id == AUDIO_ID)
632             /* The VCD standard demands that 20 zero bytes follow
633                each audio packet (see standard p. IV-8).*/
634             buf_index+=20;
635     }
636     return s->packet_size - buf_index;
637 }
638 #endif
639
640 /* Write an MPEG padding packet header. */
641 static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
642 {
643     MpegMuxContext *s = ctx->priv_data;
644     int i;
645
646     put_be32(pb, PADDING_STREAM);
647     put_be16(pb, packet_bytes - 6);
648     if (!s->is_mpeg2) {
649         put_byte(pb, 0x0f);
650         packet_bytes -= 7;
651     } else
652         packet_bytes -= 6;
653
654     for(i=0;i<packet_bytes;i++)
655         put_byte(pb, 0xff);
656 }
657
658 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
659     int nb_frames=0;
660     PacketDesc *pkt_desc= stream->premux_packet;
661
662     while(len>0){
663         if(pkt_desc->size == pkt_desc->unwritten_size)
664             nb_frames++;
665         len -= pkt_desc->unwritten_size;
666         pkt_desc= pkt_desc->next;
667     }
668
669     return nb_frames;
670 }
671
672 /* flush the packet on stream stream_index */
673 static int flush_packet(AVFormatContext *ctx, int stream_index,
674                          int64_t pts, int64_t dts, int64_t scr, int trailer_size)
675 {
676     MpegMuxContext *s = ctx->priv_data;
677     StreamInfo *stream = ctx->streams[stream_index]->priv_data;
678     uint8_t *buf_ptr;
679     int size, payload_size, startcode, id, stuffing_size, i, header_len;
680     int packet_size;
681     uint8_t buffer[128];
682     int zero_trail_bytes = 0;
683     int pad_packet_bytes = 0;
684     int pes_flags;
685     int general_pack = 0;  /*"general" pack without data specific to one stream?*/
686     int nb_frames;
687
688     id = stream->id;
689
690 #if 0
691     printf("packet ID=%2x PTS=%0.3f\n",
692            id, pts / 90000.0);
693 #endif
694
695     buf_ptr = buffer;
696
697     if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
698         /* output pack and systems header if needed */
699         size = put_pack_header(ctx, buf_ptr, scr);
700         buf_ptr += size;
701         s->last_scr= scr;
702
703         if (s->is_vcd) {
704             /* there is exactly one system header for each stream in a VCD MPEG,
705                One in the very first video packet and one in the very first
706                audio packet (see VCD standard p. IV-7 and IV-8).*/
707
708             if (stream->packet_number==0) {
709                 size = put_system_header(ctx, buf_ptr, id);
710                 buf_ptr += size;
711             }
712         } else if (s->is_dvd) {
713             if (stream->align_iframe || s->packet_number == 0){
714                 int PES_bytes_to_fill = s->packet_size - size - 10;
715
716                 if (pts != AV_NOPTS_VALUE) {
717                     if (dts != pts)
718                         PES_bytes_to_fill -= 5 + 5;
719                     else
720                         PES_bytes_to_fill -= 5;
721                 }
722
723                 if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
724                     size = put_system_header(ctx, buf_ptr, 0);
725                     buf_ptr += size;
726                     size = buf_ptr - buffer;
727                     put_buffer(&ctx->pb, buffer, size);
728
729                     put_be32(&ctx->pb, PRIVATE_STREAM_2);
730                     put_be16(&ctx->pb, 0x03d4);         // length
731                     put_byte(&ctx->pb, 0x00);           // substream ID, 00=PCI
732                     for (i = 0; i < 979; i++)
733                         put_byte(&ctx->pb, 0x00);
734
735                     put_be32(&ctx->pb, PRIVATE_STREAM_2);
736                     put_be16(&ctx->pb, 0x03fa);         // length
737                     put_byte(&ctx->pb, 0x01);           // substream ID, 01=DSI
738                     for (i = 0; i < 1017; i++)
739                         put_byte(&ctx->pb, 0x00);
740
741                     memset(buffer, 0, 128);
742                     buf_ptr = buffer;
743                     s->packet_number++;
744                     stream->align_iframe = 0;
745                     scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
746                     size = put_pack_header(ctx, buf_ptr, scr);
747                     s->last_scr= scr;
748                     buf_ptr += size;
749                     /* GOP Start */
750                 } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
751                     pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
752                 }
753             }
754         } else {
755             if ((s->packet_number % s->system_header_freq) == 0) {
756                 size = put_system_header(ctx, buf_ptr, 0);
757                 buf_ptr += size;
758             }
759         }
760     }
761     size = buf_ptr - buffer;
762     put_buffer(&ctx->pb, buffer, size);
763
764     packet_size = s->packet_size - size;
765
766     if (s->is_vcd && id == AUDIO_ID)
767         /* The VCD standard demands that 20 zero bytes follow
768            each audio pack (see standard p. IV-8).*/
769         zero_trail_bytes += 20;
770
771     if ((s->is_vcd && stream->packet_number==0)
772         || (s->is_svcd && s->packet_number==0)) {
773         /* for VCD the first pack of each stream contains only the pack header,
774            the system header and lots of padding (see VCD standard p. IV-6).
775            In the case of an audio pack, 20 zero bytes are also added at
776            the end.*/
777         /* For SVCD we fill the very first pack to increase compatibility with
778            some DVD players. Not mandated by the standard.*/
779         if (s->is_svcd)
780             general_pack = 1;    /* the system header refers to both streams and no stream data*/
781         pad_packet_bytes = packet_size - zero_trail_bytes;
782     }
783
784     packet_size -= pad_packet_bytes + zero_trail_bytes;
785
786     if (packet_size > 0) {
787
788         /* packet header size */
789         packet_size -= 6;
790
791         /* packet header */
792         if (s->is_mpeg2) {
793             header_len = 3;
794             if (stream->packet_number==0)
795                 header_len += 3; /* PES extension */
796             header_len += 1; /* obligatory stuffing byte */
797         } else {
798             header_len = 0;
799         }
800         if (pts != AV_NOPTS_VALUE) {
801             if (dts != pts)
802                 header_len += 5 + 5;
803             else
804                 header_len += 5;
805         } else {
806             if (!s->is_mpeg2)
807                 header_len++;
808         }
809
810         payload_size = packet_size - header_len;
811         if (id < 0xc0) {
812             startcode = PRIVATE_STREAM_1;
813             payload_size -= 1;
814             if (id >= 0x40) {
815                 payload_size -= 3;
816                 if (id >= 0xa0)
817                     payload_size -= 3;
818             }
819         } else {
820             startcode = 0x100 + id;
821         }
822
823         stuffing_size = payload_size - av_fifo_size(&stream->fifo);
824
825         // first byte doesnt fit -> reset pts/dts + stuffing
826         if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
827             int timestamp_len=0;
828             if(dts != pts)
829                 timestamp_len += 5;
830             if(pts != AV_NOPTS_VALUE)
831                 timestamp_len += s->is_mpeg2 ? 5 : 4;
832             pts=dts= AV_NOPTS_VALUE;
833             header_len -= timestamp_len;
834             if (s->is_dvd && stream->align_iframe) {
835                 pad_packet_bytes += timestamp_len;
836                 packet_size -= timestamp_len;
837             } else {
838                 payload_size += timestamp_len;
839             }
840             stuffing_size += timestamp_len;
841             if(payload_size > trailer_size)
842                 stuffing_size += payload_size - trailer_size;
843         }
844
845         if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
846             packet_size += pad_packet_bytes;
847             payload_size += pad_packet_bytes; // undo the previous adjustment
848             if (stuffing_size < 0) {
849                 stuffing_size = pad_packet_bytes;
850             } else {
851                 stuffing_size += pad_packet_bytes;
852             }
853             pad_packet_bytes = 0;
854         }
855
856         if (stuffing_size < 0)
857             stuffing_size = 0;
858         if (stuffing_size > 16) {    /*<=16 for MPEG-1, <=32 for MPEG-2*/
859             pad_packet_bytes += stuffing_size;
860             packet_size -= stuffing_size;
861             payload_size -= stuffing_size;
862             stuffing_size = 0;
863         }
864
865         nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
866
867         put_be32(&ctx->pb, startcode);
868
869         put_be16(&ctx->pb, packet_size);
870
871         if (!s->is_mpeg2)
872             for(i=0;i<stuffing_size;i++)
873                 put_byte(&ctx->pb, 0xff);
874
875         if (s->is_mpeg2) {
876             put_byte(&ctx->pb, 0x80); /* mpeg2 id */
877
878             pes_flags=0;
879
880             if (pts != AV_NOPTS_VALUE) {
881                 pes_flags |= 0x80;
882                 if (dts != pts)
883                     pes_flags |= 0x40;
884             }
885
886             /* Both the MPEG-2 and the SVCD standards demand that the
887                P-STD_buffer_size field be included in the first packet of
888                every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
889                and MPEG-2 standard 2.7.7) */
890             if (stream->packet_number == 0)
891                 pes_flags |= 0x01;
892
893             put_byte(&ctx->pb, pes_flags); /* flags */
894             put_byte(&ctx->pb, header_len - 3 + stuffing_size);
895
896             if (pes_flags & 0x80)  /*write pts*/
897                 put_timestamp(&ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
898             if (pes_flags & 0x40)  /*write dts*/
899                 put_timestamp(&ctx->pb, 0x01, dts);
900
901             if (pes_flags & 0x01) {  /*write pes extension*/
902                 put_byte(&ctx->pb, 0x10); /* flags */
903
904                 /* P-STD buffer info */
905                 if (id == AUDIO_ID)
906                     put_be16(&ctx->pb, 0x4000 | stream->max_buffer_size/128);
907                 else
908                     put_be16(&ctx->pb, 0x6000 | stream->max_buffer_size/1024);
909             }
910
911         } else {
912             if (pts != AV_NOPTS_VALUE) {
913                 if (dts != pts) {
914                     put_timestamp(&ctx->pb, 0x03, pts);
915                     put_timestamp(&ctx->pb, 0x01, dts);
916                 } else {
917                     put_timestamp(&ctx->pb, 0x02, pts);
918                 }
919             } else {
920                 put_byte(&ctx->pb, 0x0f);
921             }
922         }
923
924         if (s->is_mpeg2) {
925             /* special stuffing byte that is always written
926                to prevent accidental generation of start codes. */
927             put_byte(&ctx->pb, 0xff);
928
929             for(i=0;i<stuffing_size;i++)
930                 put_byte(&ctx->pb, 0xff);
931         }
932
933         if (startcode == PRIVATE_STREAM_1) {
934             put_byte(&ctx->pb, id);
935             if (id >= 0xa0) {
936                 /* LPCM (XXX: check nb_frames) */
937                 put_byte(&ctx->pb, 7);
938                 put_be16(&ctx->pb, 4); /* skip 3 header bytes */
939                 put_byte(&ctx->pb, stream->lpcm_header[0]);
940                 put_byte(&ctx->pb, stream->lpcm_header[1]);
941                 put_byte(&ctx->pb, stream->lpcm_header[2]);
942             } else if (id >= 0x40) {
943                 /* AC3 */
944                 put_byte(&ctx->pb, nb_frames);
945                 put_be16(&ctx->pb, trailer_size+1);
946             }
947         }
948
949         /* output data */
950         if(av_fifo_generic_read(&stream->fifo, payload_size - stuffing_size, &put_buffer, &ctx->pb) < 0)
951             return -1;
952         stream->bytes_to_iframe -= payload_size - stuffing_size;
953     }else{
954         payload_size=
955         stuffing_size= 0;
956     }
957
958     if (pad_packet_bytes > 0)
959         put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);
960
961     for(i=0;i<zero_trail_bytes;i++)
962         put_byte(&ctx->pb, 0x00);
963
964     put_flush_packet(&ctx->pb);
965
966     s->packet_number++;
967
968     /* only increase the stream packet number if this pack actually contains
969        something that is specific to this stream! I.e. a dedicated header
970        or some data.*/
971     if (!general_pack)
972         stream->packet_number++;
973
974     return payload_size - stuffing_size;
975 }
976
977 static void put_vcd_padding_sector(AVFormatContext *ctx)
978 {
979     /* There are two ways to do this padding: writing a sector/pack
980        of 0 values, or writing an MPEG padding pack. Both seem to
981        work with most decoders, BUT the VCD standard only allows a 0-sector
982        (see standard p. IV-4, IV-5).
983        So a 0-sector it is...*/
984
985     MpegMuxContext *s = ctx->priv_data;
986     int i;
987
988     for(i=0;i<s->packet_size;i++)
989         put_byte(&ctx->pb, 0);
990
991     s->vcd_padding_bytes_written += s->packet_size;
992
993     put_flush_packet(&ctx->pb);
994
995     /* increasing the packet number is correct. The SCR of the following packs
996        is calculated from the packet_number and it has to include the padding
997        sector (it represents the sector index, not the MPEG pack index)
998        (see VCD standard p. IV-6)*/
999     s->packet_number++;
1000 }
1001
1002 #if 0 /* unused, remove? */
1003 static int64_t get_vcd_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
1004 {
1005     MpegMuxContext *s = ctx->priv_data;
1006     int64_t scr;
1007
1008         /* Since the data delivery rate is constant, SCR is computed
1009            using the formula C + i * 1200 where C is the start constant
1010            and i is the pack index.
1011            It is recommended that SCR 0 is at the beginning of the VCD front
1012            margin (a sequence of empty Form 2 sectors on the CD).
1013            It is recommended that the front margin is 30 sectors long, so
1014            we use C = 30*1200 = 36000
1015            (Note that even if the front margin is not 30 sectors the file
1016            will still be correct according to the standard. It just won't have
1017            the "recommended" value).*/
1018         scr = 36000 + s->packet_number * 1200;
1019
1020     return scr;
1021 }
1022 #endif
1023
1024 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
1025 //    MpegMuxContext *s = ctx->priv_data;
1026     int i;
1027
1028     for(i=0; i<ctx->nb_streams; i++){
1029         AVStream *st = ctx->streams[i];
1030         StreamInfo *stream = st->priv_data;
1031         PacketDesc *pkt_desc= stream->predecode_packet;
1032
1033         while(pkt_desc && scr > pkt_desc->dts){ //FIXME > vs >=
1034             if(stream->buffer_index < pkt_desc->size ||
1035                stream->predecode_packet == stream->premux_packet){
1036                 av_log(ctx, AV_LOG_ERROR, "buffer underflow\n");
1037                 break;
1038             }
1039             stream->buffer_index -= pkt_desc->size;
1040
1041             stream->predecode_packet= pkt_desc->next;
1042             av_freep(&pkt_desc);
1043         }
1044     }
1045
1046     return 0;
1047 }
1048
1049 static int output_packet(AVFormatContext *ctx, int flush){
1050     MpegMuxContext *s = ctx->priv_data;
1051     AVStream *st;
1052     StreamInfo *stream;
1053     int i, avail_space, es_size, trailer_size;
1054     int best_i= -1;
1055     int best_score= INT_MIN;
1056     int ignore_constraints=0;
1057     int64_t scr= s->last_scr;
1058     PacketDesc *timestamp_packet;
1059     const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1060
1061 retry:
1062     for(i=0; i<ctx->nb_streams; i++){
1063         AVStream *st = ctx->streams[i];
1064         StreamInfo *stream = st->priv_data;
1065         const int avail_data=  av_fifo_size(&stream->fifo);
1066         const int space= stream->max_buffer_size - stream->buffer_index;
1067         int rel_space= 1024*space / stream->max_buffer_size;
1068         PacketDesc *next_pkt= stream->premux_packet;
1069
1070         /* for subtitle, a single PES packet must be generated,
1071            so we flush after every single subtitle packet */
1072         if(s->packet_size > avail_data && !flush
1073            && st->codec->codec_type != CODEC_TYPE_SUBTITLE)
1074             return 0;
1075         if(avail_data==0)
1076             continue;
1077         assert(avail_data>0);
1078
1079         if(space < s->packet_size && !ignore_constraints)
1080             continue;
1081
1082         if(next_pkt && next_pkt->dts - scr > max_delay)
1083             continue;
1084
1085         if(rel_space > best_score){
1086             best_score= rel_space;
1087             best_i = i;
1088             avail_space= space;
1089         }
1090     }
1091
1092     if(best_i < 0){
1093         int64_t best_dts= INT64_MAX;
1094
1095         for(i=0; i<ctx->nb_streams; i++){
1096             AVStream *st = ctx->streams[i];
1097             StreamInfo *stream = st->priv_data;
1098             PacketDesc *pkt_desc= stream->predecode_packet;
1099             if(pkt_desc && pkt_desc->dts < best_dts)
1100                 best_dts= pkt_desc->dts;
1101         }
1102
1103 #if 0
1104         av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n",
1105                scr/90000.0, best_dts/90000.0);
1106 #endif
1107         if(best_dts == INT64_MAX)
1108             return 0;
1109
1110         if(scr >= best_dts+1 && !ignore_constraints){
1111             av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
1112             ignore_constraints= 1;
1113         }
1114         scr= FFMAX(best_dts+1, scr);
1115         if(remove_decoded_packets(ctx, scr) < 0)
1116             return -1;
1117         goto retry;
1118     }
1119
1120     assert(best_i >= 0);
1121
1122     st = ctx->streams[best_i];
1123     stream = st->priv_data;
1124
1125     assert(av_fifo_size(&stream->fifo) > 0);
1126
1127     assert(avail_space >= s->packet_size || ignore_constraints);
1128
1129     timestamp_packet= stream->premux_packet;
1130     if(timestamp_packet->unwritten_size == timestamp_packet->size){
1131         trailer_size= 0;
1132     }else{
1133         trailer_size= timestamp_packet->unwritten_size;
1134         timestamp_packet= timestamp_packet->next;
1135     }
1136
1137     if(timestamp_packet){
1138 //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);
1139         es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1140     }else{
1141         assert(av_fifo_size(&stream->fifo) == trailer_size);
1142         es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1143     }
1144
1145     if (s->is_vcd) {
1146         /* Write one or more padding sectors, if necessary, to reach
1147            the constant overall bitrate.*/
1148         int vcd_pad_bytes;
1149
1150         while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1151             put_vcd_padding_sector(ctx);
1152             s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1153         }
1154     }
1155
1156     stream->buffer_index += es_size;
1157     s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1158
1159     while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1160         es_size -= stream->premux_packet->unwritten_size;
1161         stream->premux_packet= stream->premux_packet->next;
1162     }
1163     if(es_size)
1164         stream->premux_packet->unwritten_size -= es_size;
1165
1166     if(remove_decoded_packets(ctx, s->last_scr) < 0)
1167         return -1;
1168
1169     return 1;
1170 }
1171
1172 static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
1173 {
1174     MpegMuxContext *s = ctx->priv_data;
1175     int stream_index= pkt->stream_index;
1176     int size= pkt->size;
1177     uint8_t *buf= pkt->data;
1178     AVStream *st = ctx->streams[stream_index];
1179     StreamInfo *stream = st->priv_data;
1180     int64_t pts, dts;
1181     PacketDesc *pkt_desc;
1182     const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
1183     const int is_iframe = st->codec->codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
1184
1185     pts= pkt->pts;
1186     dts= pkt->dts;
1187
1188     if(pts != AV_NOPTS_VALUE) pts += preload;
1189     if(dts != AV_NOPTS_VALUE) dts += preload;
1190
1191 //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);
1192     if (!stream->premux_packet)
1193         stream->next_packet = &stream->premux_packet;
1194     *stream->next_packet=
1195     pkt_desc= av_mallocz(sizeof(PacketDesc));
1196     pkt_desc->pts= pts;
1197     pkt_desc->dts= dts;
1198     pkt_desc->unwritten_size=
1199     pkt_desc->size= size;
1200     if(!stream->predecode_packet)
1201         stream->predecode_packet= pkt_desc;
1202     stream->next_packet= &pkt_desc->next;
1203
1204     av_fifo_realloc(&stream->fifo, av_fifo_size(&stream->fifo) + size + 1);
1205
1206     if (s->is_dvd){
1207         if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1208             stream->bytes_to_iframe = av_fifo_size(&stream->fifo);
1209             stream->align_iframe = 1;
1210             stream->vobu_start_pts = pts;
1211         } else {
1212             stream->align_iframe = 0;
1213         }
1214     }
1215
1216     av_fifo_write(&stream->fifo, buf, size);
1217
1218     for(;;){
1219         int ret= output_packet(ctx, 0);
1220         if(ret<=0)
1221             return ret;
1222     }
1223 }
1224
1225 static int mpeg_mux_end(AVFormatContext *ctx)
1226 {
1227 //    MpegMuxContext *s = ctx->priv_data;
1228     StreamInfo *stream;
1229     int i;
1230
1231     for(;;){
1232         int ret= output_packet(ctx, 1);
1233         if(ret<0)
1234             return ret;
1235         else if(ret==0)
1236             break;
1237     }
1238
1239     /* End header according to MPEG1 systems standard. We do not write
1240        it as it is usually not needed by decoders and because it
1241        complicates MPEG stream concatenation. */
1242     //put_be32(&ctx->pb, ISO_11172_END_CODE);
1243     //put_flush_packet(&ctx->pb);
1244
1245     for(i=0;i<ctx->nb_streams;i++) {
1246         stream = ctx->streams[i]->priv_data;
1247
1248         assert(av_fifo_size(&stream->fifo) == 0);
1249         av_fifo_free(&stream->fifo);
1250     }
1251     return 0;
1252 }
1253 #endif //CONFIG_MUXERS
1254
1255 /*********************************************/
1256 /* demux code */
1257
1258 #define MAX_SYNC_SIZE 100000
1259
1260 static int cdxa_probe(AVProbeData *p)
1261 {
1262     /* check file header */
1263     if (p->buf[0] == 'R' && p->buf[1] == 'I' &&
1264         p->buf[2] == 'F' && p->buf[3] == 'F' &&
1265         p->buf[8] == 'C' && p->buf[9] == 'D' &&
1266         p->buf[10] == 'X' && p->buf[11] == 'A')
1267         return AVPROBE_SCORE_MAX;
1268     else
1269         return 0;
1270 }
1271
1272 static int mpegps_probe(AVProbeData *p)
1273 {
1274     uint32_t code= -1;
1275     int sys=0, pspack=0, priv1=0, vid=0, audio=0;
1276     int i;
1277     int score=0;
1278
1279     score = cdxa_probe(p);
1280     if (score > 0) return score;
1281
1282     /* Search for MPEG stream */
1283     for(i=0; i<p->buf_size; i++){
1284         code = (code<<8) + p->buf[i];
1285         if ((code & 0xffffff00) == 0x100) {
1286             if(code == SYSTEM_HEADER_START_CODE) sys++;
1287             else if(code == PRIVATE_STREAM_1)    priv1++;
1288             else if(code == PACK_START_CODE)     pspack++;
1289             else if((code & 0xf0) == VIDEO_ID)   vid++;
1290             else if((code & 0xe0) == AUDIO_ID)   audio++;
1291         }
1292     }
1293
1294     if(vid || audio)            /* invalid VDR files nd short PES streams */
1295         score= AVPROBE_SCORE_MAX/4;
1296
1297 //av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d\n", sys, priv1, pspack,vid, audio);
1298     if(sys && sys*9 <= pspack*10)
1299         return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1300     if((priv1 || vid || audio) && (priv1+vid+audio)*9 <= pspack*10)
1301         return AVPROBE_SCORE_MAX/2+2; // +1 for .mpg
1302     if((!!vid ^ !!audio) && (audio+vid > 1) && !sys && !pspack) /* PES stream */
1303         return AVPROBE_SCORE_MAX/2+2;
1304
1305     //02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
1306     return score;
1307 }
1308
1309
1310 typedef struct MpegDemuxContext {
1311     int32_t header_state;
1312     unsigned char psm_es_type[256];
1313 } MpegDemuxContext;
1314
1315 static int mpegps_read_header(AVFormatContext *s,
1316                               AVFormatParameters *ap)
1317 {
1318     MpegDemuxContext *m = s->priv_data;
1319     m->header_state = 0xff;
1320     s->ctx_flags |= AVFMTCTX_NOHEADER;
1321
1322     /* no need to do more */
1323     return 0;
1324 }
1325
1326 static int64_t get_pts(ByteIOContext *pb, int c)
1327 {
1328     int64_t pts;
1329     int val;
1330
1331     if (c < 0)
1332         c = get_byte(pb);
1333     pts = (int64_t)((c >> 1) & 0x07) << 30;
1334     val = get_be16(pb);
1335     pts |= (int64_t)(val >> 1) << 15;
1336     val = get_be16(pb);
1337     pts |= (int64_t)(val >> 1);
1338     return pts;
1339 }
1340
1341 static int find_next_start_code(ByteIOContext *pb, int *size_ptr,
1342                                 int32_t *header_state)
1343 {
1344     unsigned int state, v;
1345     int val, n;
1346
1347     state = *header_state;
1348     n = *size_ptr;
1349     while (n > 0) {
1350         if (url_feof(pb))
1351             break;
1352         v = get_byte(pb);
1353         n--;
1354         if (state == 0x000001) {
1355             state = ((state << 8) | v) & 0xffffff;
1356             val = state;
1357             goto found;
1358         }
1359         state = ((state << 8) | v) & 0xffffff;
1360     }
1361     val = -1;
1362  found:
1363     *header_state = state;
1364     *size_ptr = n;
1365     return val;
1366 }
1367
1368 #if 0 /* unused, remove? */
1369 /* XXX: optimize */
1370 static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1371 {
1372     int64_t pos, pos_start;
1373     int max_size, start_code;
1374
1375     max_size = *size_ptr;
1376     pos_start = url_ftell(pb);
1377
1378     /* in order to go faster, we fill the buffer */
1379     pos = pos_start - 16386;
1380     if (pos < 0)
1381         pos = 0;
1382     url_fseek(pb, pos, SEEK_SET);
1383     get_byte(pb);
1384
1385     pos = pos_start;
1386     for(;;) {
1387         pos--;
1388         if (pos < 0 || (pos_start - pos) >= max_size) {
1389             start_code = -1;
1390             goto the_end;
1391         }
1392         url_fseek(pb, pos, SEEK_SET);
1393         start_code = get_be32(pb);
1394         if ((start_code & 0xffffff00) == 0x100)
1395             break;
1396     }
1397  the_end:
1398     *size_ptr = pos_start - pos;
1399     return start_code;
1400 }
1401 #endif
1402
1403 /**
1404  * Extracts stream types from a program stream map
1405  * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
1406  *
1407  * @return number of bytes occupied by PSM in the bitstream
1408  */
1409 static long mpegps_psm_parse(MpegDemuxContext *m, ByteIOContext *pb)
1410 {
1411     int psm_length, ps_info_length, es_map_length;
1412
1413     psm_length = get_be16(pb);
1414     get_byte(pb);
1415     get_byte(pb);
1416     ps_info_length = get_be16(pb);
1417
1418     /* skip program_stream_info */
1419     url_fskip(pb, ps_info_length);
1420     es_map_length = get_be16(pb);
1421
1422     /* at least one es available? */
1423     while (es_map_length >= 4){
1424         unsigned char type = get_byte(pb);
1425         unsigned char es_id = get_byte(pb);
1426         uint16_t es_info_length = get_be16(pb);
1427         /* remember mapping from stream id to stream type */
1428         m->psm_es_type[es_id] = type;
1429         /* skip program_stream_info */
1430         url_fskip(pb, es_info_length);
1431         es_map_length -= 4 + es_info_length;
1432     }
1433     get_be32(pb); /* crc32 */
1434     return 2 + psm_length;
1435 }
1436
1437 /* read the next PES header. Return its position in ppos
1438    (if not NULL), and its start code, pts and dts.
1439  */
1440 static int mpegps_read_pes_header(AVFormatContext *s,
1441                                   int64_t *ppos, int *pstart_code,
1442                                   int64_t *ppts, int64_t *pdts)
1443 {
1444     MpegDemuxContext *m = s->priv_data;
1445     int len, size, startcode, c, flags, header_len;
1446     int pes_ext, ext2_len, id_ext, skip;
1447     int64_t pts, dts;
1448     int64_t last_sync= url_ftell(&s->pb);
1449
1450  error_redo:
1451         url_fseek(&s->pb, last_sync, SEEK_SET);
1452  redo:
1453         /* next start code (should be immediately after) */
1454         m->header_state = 0xff;
1455         size = MAX_SYNC_SIZE;
1456         startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1457         last_sync = url_ftell(&s->pb);
1458     //printf("startcode=%x pos=0x%"PRIx64"\n", startcode, url_ftell(&s->pb));
1459     if (startcode < 0)
1460         return AVERROR_IO;
1461     if (startcode == PACK_START_CODE)
1462         goto redo;
1463     if (startcode == SYSTEM_HEADER_START_CODE)
1464         goto redo;
1465     if (startcode == PADDING_STREAM ||
1466         startcode == PRIVATE_STREAM_2) {
1467         /* skip them */
1468         len = get_be16(&s->pb);
1469         url_fskip(&s->pb, len);
1470         goto redo;
1471     }
1472     if (startcode == PROGRAM_STREAM_MAP) {
1473         mpegps_psm_parse(m, &s->pb);
1474         goto redo;
1475     }
1476
1477     /* find matching stream */
1478     if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1479           (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1480           (startcode == 0x1bd) || (startcode == 0x1fd)))
1481         goto redo;
1482     if (ppos) {
1483         *ppos = url_ftell(&s->pb) - 4;
1484     }
1485     len = get_be16(&s->pb);
1486     pts =
1487     dts = AV_NOPTS_VALUE;
1488     /* stuffing */
1489     for(;;) {
1490         if (len < 1)
1491             goto error_redo;
1492         c = get_byte(&s->pb);
1493         len--;
1494         /* XXX: for mpeg1, should test only bit 7 */
1495         if (c != 0xff)
1496             break;
1497     }
1498     if ((c & 0xc0) == 0x40) {
1499         /* buffer scale & size */
1500         get_byte(&s->pb);
1501         c = get_byte(&s->pb);
1502         len -= 2;
1503     }
1504     if ((c & 0xe0) == 0x20) {
1505         dts = pts = get_pts(&s->pb, c);
1506         len -= 4;
1507         if (c & 0x10){
1508             dts = get_pts(&s->pb, -1);
1509             len -= 5;
1510         }
1511     } else if ((c & 0xc0) == 0x80) {
1512         /* mpeg 2 PES */
1513 #if 0 /* some streams have this field set for no apparent reason */
1514         if ((c & 0x30) != 0) {
1515             /* Encrypted multiplex not handled */
1516             goto redo;
1517         }
1518 #endif
1519         flags = get_byte(&s->pb);
1520         header_len = get_byte(&s->pb);
1521         len -= 2;
1522         if (header_len > len)
1523             goto error_redo;
1524         len -= header_len;
1525         if (flags & 0x80) {
1526             dts = pts = get_pts(&s->pb, -1);
1527             header_len -= 5;
1528             if (flags & 0x40) {
1529                 dts = get_pts(&s->pb, -1);
1530                 header_len -= 5;
1531             }
1532         }
1533         if (flags & 0x01) { /* PES extension */
1534             pes_ext = get_byte(&s->pb);
1535             header_len--;
1536             if (pes_ext & 0x40) { /* pack header - should be zero in PS */
1537                 goto error_redo;
1538             }
1539             /* Skip PES private data, program packet sequence counter and P-STD buffer */
1540             skip = (pes_ext >> 4) & 0xb;
1541             skip += skip & 0x9;
1542             url_fskip(&s->pb, skip);
1543             header_len -= skip;
1544
1545             if (pes_ext & 0x01) { /* PES extension 2 */
1546                 ext2_len = get_byte(&s->pb);
1547                 header_len--;
1548                 if ((ext2_len & 0x7f) > 0) {
1549                     id_ext = get_byte(&s->pb);
1550                     if ((id_ext & 0x80) == 0)
1551                         startcode = ((startcode & 0xff) << 8) | id_ext;
1552                     header_len--;
1553                 }
1554             }
1555         }
1556         if(header_len < 0)
1557             goto error_redo;
1558         url_fskip(&s->pb, header_len);
1559     }
1560     else if( c!= 0xf )
1561         goto redo;
1562
1563     if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
1564         startcode = get_byte(&s->pb);
1565         len--;
1566         if (startcode >= 0x80 && startcode <= 0xcf) {
1567             /* audio: skip header */
1568             get_byte(&s->pb);
1569             get_byte(&s->pb);
1570             get_byte(&s->pb);
1571             len -= 3;
1572             if (startcode >= 0xb0 && startcode <= 0xbf) {
1573                 /* MLP/TrueHD audio has a 4-byte header */
1574                 get_byte(&s->pb);
1575                 len--;
1576             }
1577         }
1578     }
1579     if(len<0)
1580         goto error_redo;
1581     if(dts != AV_NOPTS_VALUE && ppos){
1582         int i;
1583         for(i=0; i<s->nb_streams; i++){
1584             if(startcode == s->streams[i]->id) {
1585                 av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
1586             }
1587         }
1588     }
1589
1590     *pstart_code = startcode;
1591     *ppts = pts;
1592     *pdts = dts;
1593     return len;
1594 }
1595
1596 static int mpegps_read_packet(AVFormatContext *s,
1597                               AVPacket *pkt)
1598 {
1599     MpegDemuxContext *m = s->priv_data;
1600     AVStream *st;
1601     int len, startcode, i, type, codec_id = 0, es_type;
1602     int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1603
1604  redo:
1605     len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
1606     if (len < 0)
1607         return len;
1608
1609     /* now find stream */
1610     for(i=0;i<s->nb_streams;i++) {
1611         st = s->streams[i];
1612         if (st->id == startcode)
1613             goto found;
1614     }
1615
1616     es_type = m->psm_es_type[startcode & 0xff];
1617     if(es_type > 0){
1618         if(es_type == STREAM_TYPE_VIDEO_MPEG1){
1619             codec_id = CODEC_ID_MPEG2VIDEO;
1620             type = CODEC_TYPE_VIDEO;
1621         } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
1622             codec_id = CODEC_ID_MPEG2VIDEO;
1623             type = CODEC_TYPE_VIDEO;
1624         } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||
1625                   es_type == STREAM_TYPE_AUDIO_MPEG2){
1626             codec_id = CODEC_ID_MP3;
1627             type = CODEC_TYPE_AUDIO;
1628         } else if(es_type == STREAM_TYPE_AUDIO_AAC){
1629             codec_id = CODEC_ID_AAC;
1630             type = CODEC_TYPE_AUDIO;
1631         } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
1632             codec_id = CODEC_ID_MPEG4;
1633             type = CODEC_TYPE_VIDEO;
1634         } else if(es_type == STREAM_TYPE_VIDEO_H264){
1635             codec_id = CODEC_ID_H264;
1636             type = CODEC_TYPE_VIDEO;
1637         } else if(es_type == STREAM_TYPE_AUDIO_AC3){
1638             codec_id = CODEC_ID_AC3;
1639             type = CODEC_TYPE_AUDIO;
1640         } else {
1641             goto skip;
1642         }
1643     } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1644         static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
1645         unsigned char buf[8];
1646         get_buffer(&s->pb, buf, 8);
1647         url_fseek(&s->pb, -8, SEEK_CUR);
1648         if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
1649             codec_id = CODEC_ID_CAVS;
1650         else
1651             codec_id = CODEC_ID_MPEG2VIDEO;
1652         type = CODEC_TYPE_VIDEO;
1653     } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1654         type = CODEC_TYPE_AUDIO;
1655         codec_id = CODEC_ID_MP2;
1656     } else if (startcode >= 0x80 && startcode <= 0x87) {
1657         type = CODEC_TYPE_AUDIO;
1658         codec_id = CODEC_ID_AC3;
1659     } else if ((startcode >= 0x88 && startcode <= 0x8f)
1660                ||( startcode >= 0x98 && startcode <= 0x9f)) {
1661         /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
1662         type = CODEC_TYPE_AUDIO;
1663         codec_id = CODEC_ID_DTS;
1664     } else if (startcode >= 0xa0 && startcode <= 0xaf) {
1665         type = CODEC_TYPE_AUDIO;
1666         codec_id = CODEC_ID_PCM_S16BE;
1667     } else if (startcode >= 0xb0 && startcode <= 0xbf) {
1668         type = CODEC_TYPE_AUDIO;
1669         codec_id = CODEC_ID_MLP;
1670     } else if (startcode >= 0xc0 && startcode <= 0xcf) {
1671         /* Used for both AC-3 and E-AC-3 in EVOB files */
1672         type = CODEC_TYPE_AUDIO;
1673         codec_id = CODEC_ID_AC3;
1674     } else if (startcode >= 0x20 && startcode <= 0x3f) {
1675         type = CODEC_TYPE_SUBTITLE;
1676         codec_id = CODEC_ID_DVD_SUBTITLE;
1677     } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
1678         type = CODEC_TYPE_VIDEO;
1679         codec_id = CODEC_ID_VC1;
1680     } else {
1681     skip:
1682         /* skip packet */
1683         url_fskip(&s->pb, len);
1684         goto redo;
1685     }
1686     /* no stream found: add a new stream */
1687     st = av_new_stream(s, startcode);
1688     if (!st)
1689         goto skip;
1690     st->codec->codec_type = type;
1691     st->codec->codec_id = codec_id;
1692     if (codec_id != CODEC_ID_PCM_S16BE)
1693         st->need_parsing = AVSTREAM_PARSE_FULL;
1694  found:
1695     if(st->discard >= AVDISCARD_ALL)
1696         goto skip;
1697     if (startcode >= 0xa0 && startcode <= 0xaf) {
1698         int b1, freq;
1699
1700         /* for LPCM, we just skip the header and consider it is raw
1701            audio data */
1702         if (len <= 3)
1703             goto skip;
1704         get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1705         b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1706         get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1707         len -= 3;
1708         freq = (b1 >> 4) & 3;
1709         st->codec->sample_rate = lpcm_freq_tab[freq];
1710         st->codec->channels = 1 + (b1 & 7);
1711         st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * 2;
1712     }
1713     av_new_packet(pkt, len);
1714     get_buffer(&s->pb, pkt->data, pkt->size);
1715     pkt->pts = pts;
1716     pkt->dts = dts;
1717     pkt->stream_index = st->index;
1718 #if 0
1719     av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
1720            pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0, pkt->size);
1721 #endif
1722
1723     return 0;
1724 }
1725
1726 static int mpegps_read_close(AVFormatContext *s)
1727 {
1728     return 0;
1729 }
1730
1731 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
1732                                int64_t *ppos, int64_t pos_limit)
1733 {
1734     int len, startcode;
1735     int64_t pos, pts, dts;
1736
1737     pos = *ppos;
1738 #ifdef DEBUG_SEEK
1739     printf("read_dts: pos=0x%"PRIx64" next=%d -> ", pos, find_next);
1740 #endif
1741     url_fseek(&s->pb, pos, SEEK_SET);
1742     for(;;) {
1743         len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
1744         if (len < 0) {
1745 #ifdef DEBUG_SEEK
1746             printf("none (ret=%d)\n", len);
1747 #endif
1748             return AV_NOPTS_VALUE;
1749         }
1750         if (startcode == s->streams[stream_index]->id &&
1751             dts != AV_NOPTS_VALUE) {
1752             break;
1753         }
1754         url_fskip(&s->pb, len);
1755     }
1756 #ifdef DEBUG_SEEK
1757     printf("pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n", pos, dts, dts / 90000.0);
1758 #endif
1759     *ppos = pos;
1760     return dts;
1761 }
1762
1763 #ifdef CONFIG_MPEG1SYSTEM_MUXER
1764 AVOutputFormat mpeg1system_muxer = {
1765     "mpeg",
1766     "MPEG1 System format",
1767     "video/mpeg",
1768     "mpg,mpeg",
1769     sizeof(MpegMuxContext),
1770     CODEC_ID_MP2,
1771     CODEC_ID_MPEG1VIDEO,
1772     mpeg_mux_init,
1773     mpeg_mux_write_packet,
1774     mpeg_mux_end,
1775 };
1776 #endif
1777 #ifdef CONFIG_MPEG1VCD_MUXER
1778 AVOutputFormat mpeg1vcd_muxer = {
1779     "vcd",
1780     "MPEG1 System format (VCD)",
1781     "video/mpeg",
1782     NULL,
1783     sizeof(MpegMuxContext),
1784     CODEC_ID_MP2,
1785     CODEC_ID_MPEG1VIDEO,
1786     mpeg_mux_init,
1787     mpeg_mux_write_packet,
1788     mpeg_mux_end,
1789 };
1790 #endif
1791 #ifdef CONFIG_MPEG2VOB_MUXER
1792 AVOutputFormat mpeg2vob_muxer = {
1793     "vob",
1794     "MPEG2 PS format (VOB)",
1795     "video/mpeg",
1796     "vob",
1797     sizeof(MpegMuxContext),
1798     CODEC_ID_MP2,
1799     CODEC_ID_MPEG2VIDEO,
1800     mpeg_mux_init,
1801     mpeg_mux_write_packet,
1802     mpeg_mux_end,
1803 };
1804 #endif
1805
1806 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1807 #ifdef CONFIG_MPEG2SVCD_MUXER
1808 AVOutputFormat mpeg2svcd_muxer = {
1809     "svcd",
1810     "MPEG2 PS format (VOB)",
1811     "video/mpeg",
1812     "vob",
1813     sizeof(MpegMuxContext),
1814     CODEC_ID_MP2,
1815     CODEC_ID_MPEG2VIDEO,
1816     mpeg_mux_init,
1817     mpeg_mux_write_packet,
1818     mpeg_mux_end,
1819 };
1820 #endif
1821
1822 /*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1823 #ifdef CONFIG_MPEG2DVD_MUXER
1824 AVOutputFormat mpeg2dvd_muxer = {
1825     "dvd",
1826     "MPEG2 PS format (DVD VOB)",
1827     "video/mpeg",
1828     "dvd",
1829     sizeof(MpegMuxContext),
1830     CODEC_ID_MP2,
1831     CODEC_ID_MPEG2VIDEO,
1832     mpeg_mux_init,
1833     mpeg_mux_write_packet,
1834     mpeg_mux_end,
1835 };
1836 #endif
1837
1838 #ifdef CONFIG_MPEGPS_DEMUXER
1839 AVInputFormat mpegps_demuxer = {
1840     "mpeg",
1841     "MPEG PS format",
1842     sizeof(MpegDemuxContext),
1843     mpegps_probe,
1844     mpegps_read_header,
1845     mpegps_read_packet,
1846     mpegps_read_close,
1847     NULL, //mpegps_read_seek,
1848     mpegps_read_dts,
1849     .flags = AVFMT_SHOW_IDS,
1850 };
1851 #endif