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