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