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