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