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