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