ffmpeg / libavformat / mpegtsenc.c @ 2874c81c
History | View | Annotate | Download (28.6 KB)
1 |
/*
|
---|---|
2 |
* MPEG2 transport stream (aka DVB) muxer
|
3 |
* Copyright (c) 2003 Fabrice Bellard
|
4 |
*
|
5 |
* This file is part of FFmpeg.
|
6 |
*
|
7 |
* FFmpeg is free software; you can redistribute it and/or
|
8 |
* modify it under the terms of the GNU Lesser General Public
|
9 |
* License as published by the Free Software Foundation; either
|
10 |
* version 2.1 of the License, or (at your option) any later version.
|
11 |
*
|
12 |
* FFmpeg is distributed in the hope that it will be useful,
|
13 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
14 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
15 |
* Lesser General Public License for more details.
|
16 |
*
|
17 |
* You should have received a copy of the GNU Lesser General Public
|
18 |
* License along with FFmpeg; if not, write to the Free Software
|
19 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
20 |
*/
|
21 |
|
22 |
#include "libavutil/bswap.h" |
23 |
#include "libavutil/crc.h" |
24 |
#include "libavcodec/mpegvideo.h" |
25 |
#include "avformat.h" |
26 |
#include "mpegts.h" |
27 |
#include "adts.h" |
28 |
|
29 |
/* write DVB SI sections */
|
30 |
|
31 |
/*********************************************/
|
32 |
/* mpegts section writer */
|
33 |
|
34 |
typedef struct MpegTSSection { |
35 |
int pid;
|
36 |
int cc;
|
37 |
void (*write_packet)(struct MpegTSSection *s, const uint8_t *packet); |
38 |
void *opaque;
|
39 |
} MpegTSSection; |
40 |
|
41 |
typedef struct MpegTSService { |
42 |
MpegTSSection pmt; /* MPEG2 pmt table context */
|
43 |
int sid; /* service ID */ |
44 |
char *name;
|
45 |
char *provider_name;
|
46 |
int pcr_pid;
|
47 |
int pcr_packet_count;
|
48 |
int pcr_packet_period;
|
49 |
} MpegTSService; |
50 |
|
51 |
typedef struct MpegTSWrite { |
52 |
MpegTSSection pat; /* MPEG2 pat table */
|
53 |
MpegTSSection sdt; /* MPEG2 sdt table context */
|
54 |
MpegTSService **services; |
55 |
int sdt_packet_count;
|
56 |
int sdt_packet_period;
|
57 |
int pat_packet_count;
|
58 |
int pat_packet_period;
|
59 |
int nb_services;
|
60 |
int onid;
|
61 |
int tsid;
|
62 |
uint64_t cur_pcr; |
63 |
int mux_rate; ///< set to 1 when VBR |
64 |
} MpegTSWrite; |
65 |
|
66 |
/* NOTE: 4 bytes must be left at the end for the crc32 */
|
67 |
static void mpegts_write_section(MpegTSSection *s, uint8_t *buf, int len) |
68 |
{ |
69 |
MpegTSWrite *ts = ((AVFormatContext*)s->opaque)->priv_data; |
70 |
unsigned int crc; |
71 |
unsigned char packet[TS_PACKET_SIZE]; |
72 |
const unsigned char *buf_ptr; |
73 |
unsigned char *q; |
74 |
int first, b, len1, left;
|
75 |
|
76 |
crc = bswap_32(av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, buf, len - 4)); |
77 |
buf[len - 4] = (crc >> 24) & 0xff; |
78 |
buf[len - 3] = (crc >> 16) & 0xff; |
79 |
buf[len - 2] = (crc >> 8) & 0xff; |
80 |
buf[len - 1] = (crc) & 0xff; |
81 |
|
82 |
/* send each packet */
|
83 |
buf_ptr = buf; |
84 |
while (len > 0) { |
85 |
first = (buf == buf_ptr); |
86 |
q = packet; |
87 |
*q++ = 0x47;
|
88 |
b = (s->pid >> 8);
|
89 |
if (first)
|
90 |
b |= 0x40;
|
91 |
*q++ = b; |
92 |
*q++ = s->pid; |
93 |
s->cc = (s->cc + 1) & 0xf; |
94 |
*q++ = 0x10 | s->cc;
|
95 |
if (first)
|
96 |
*q++ = 0; /* 0 offset */ |
97 |
len1 = TS_PACKET_SIZE - (q - packet); |
98 |
if (len1 > len)
|
99 |
len1 = len; |
100 |
memcpy(q, buf_ptr, len1); |
101 |
q += len1; |
102 |
/* add known padding data */
|
103 |
left = TS_PACKET_SIZE - (q - packet); |
104 |
if (left > 0) |
105 |
memset(q, 0xff, left);
|
106 |
|
107 |
s->write_packet(s, packet); |
108 |
|
109 |
buf_ptr += len1; |
110 |
len -= len1; |
111 |
|
112 |
ts->cur_pcr += TS_PACKET_SIZE*8*90000LL/ts->mux_rate; |
113 |
} |
114 |
} |
115 |
|
116 |
static inline void put16(uint8_t **q_ptr, int val) |
117 |
{ |
118 |
uint8_t *q; |
119 |
q = *q_ptr; |
120 |
*q++ = val >> 8;
|
121 |
*q++ = val; |
122 |
*q_ptr = q; |
123 |
} |
124 |
|
125 |
static int mpegts_write_section1(MpegTSSection *s, int tid, int id, |
126 |
int version, int sec_num, int last_sec_num, |
127 |
uint8_t *buf, int len)
|
128 |
{ |
129 |
uint8_t section[1024], *q;
|
130 |
unsigned int tot_len; |
131 |
|
132 |
tot_len = 3 + 5 + len + 4; |
133 |
/* check if not too big */
|
134 |
if (tot_len > 1024) |
135 |
return -1; |
136 |
|
137 |
q = section; |
138 |
*q++ = tid; |
139 |
put16(&q, 0xb000 | (len + 5 + 4)); /* 5 byte header + 4 byte CRC */ |
140 |
put16(&q, id); |
141 |
*q++ = 0xc1 | (version << 1); /* current_next_indicator = 1 */ |
142 |
*q++ = sec_num; |
143 |
*q++ = last_sec_num; |
144 |
memcpy(q, buf, len); |
145 |
|
146 |
mpegts_write_section(s, section, tot_len); |
147 |
return 0; |
148 |
} |
149 |
|
150 |
/*********************************************/
|
151 |
/* mpegts writer */
|
152 |
|
153 |
#define DEFAULT_PMT_START_PID 0x1000 |
154 |
#define DEFAULT_START_PID 0x0100 |
155 |
#define DEFAULT_PROVIDER_NAME "FFmpeg" |
156 |
#define DEFAULT_SERVICE_NAME "Service01" |
157 |
|
158 |
/* default network id, transport stream and service identifiers */
|
159 |
#define DEFAULT_ONID 0x0001 |
160 |
#define DEFAULT_TSID 0x0001 |
161 |
#define DEFAULT_SID 0x0001 |
162 |
|
163 |
/* a PES packet header is generated every DEFAULT_PES_HEADER_FREQ packets */
|
164 |
#define DEFAULT_PES_HEADER_FREQ 16 |
165 |
#define DEFAULT_PES_PAYLOAD_SIZE ((DEFAULT_PES_HEADER_FREQ - 1) * 184 + 170) |
166 |
|
167 |
/* we retransmit the SI info at this rate */
|
168 |
#define SDT_RETRANS_TIME 500 |
169 |
#define PAT_RETRANS_TIME 100 |
170 |
#define PCR_RETRANS_TIME 20 |
171 |
|
172 |
typedef struct MpegTSWriteStream { |
173 |
struct MpegTSService *service;
|
174 |
int pid; /* stream associated pid */ |
175 |
int cc;
|
176 |
int payload_index;
|
177 |
int first_pts_check; ///< first pts check needed |
178 |
int64_t payload_pts; |
179 |
int64_t payload_dts; |
180 |
uint8_t payload[DEFAULT_PES_PAYLOAD_SIZE]; |
181 |
ADTSContext *adts; |
182 |
} MpegTSWriteStream; |
183 |
|
184 |
static void mpegts_write_pat(AVFormatContext *s) |
185 |
{ |
186 |
MpegTSWrite *ts = s->priv_data; |
187 |
MpegTSService *service; |
188 |
uint8_t data[1012], *q;
|
189 |
int i;
|
190 |
|
191 |
q = data; |
192 |
for(i = 0; i < ts->nb_services; i++) { |
193 |
service = ts->services[i]; |
194 |
put16(&q, service->sid); |
195 |
put16(&q, 0xe000 | service->pmt.pid);
|
196 |
} |
197 |
mpegts_write_section1(&ts->pat, PAT_TID, ts->tsid, 0, 0, 0, |
198 |
data, q - data); |
199 |
} |
200 |
|
201 |
static void mpegts_write_pmt(AVFormatContext *s, MpegTSService *service) |
202 |
{ |
203 |
// MpegTSWrite *ts = s->priv_data;
|
204 |
uint8_t data[1012], *q, *desc_length_ptr, *program_info_length_ptr;
|
205 |
int val, stream_type, i;
|
206 |
|
207 |
q = data; |
208 |
put16(&q, 0xe000 | service->pcr_pid);
|
209 |
|
210 |
program_info_length_ptr = q; |
211 |
q += 2; /* patched after */ |
212 |
|
213 |
/* put program info here */
|
214 |
|
215 |
val = 0xf000 | (q - program_info_length_ptr - 2); |
216 |
program_info_length_ptr[0] = val >> 8; |
217 |
program_info_length_ptr[1] = val;
|
218 |
|
219 |
for(i = 0; i < s->nb_streams; i++) { |
220 |
AVStream *st = s->streams[i]; |
221 |
MpegTSWriteStream *ts_st = st->priv_data; |
222 |
AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL,0); |
223 |
switch(st->codec->codec_id) {
|
224 |
case CODEC_ID_MPEG1VIDEO:
|
225 |
case CODEC_ID_MPEG2VIDEO:
|
226 |
stream_type = STREAM_TYPE_VIDEO_MPEG2; |
227 |
break;
|
228 |
case CODEC_ID_MPEG4:
|
229 |
stream_type = STREAM_TYPE_VIDEO_MPEG4; |
230 |
break;
|
231 |
case CODEC_ID_H264:
|
232 |
stream_type = STREAM_TYPE_VIDEO_H264; |
233 |
break;
|
234 |
case CODEC_ID_DIRAC:
|
235 |
stream_type = STREAM_TYPE_VIDEO_DIRAC; |
236 |
break;
|
237 |
case CODEC_ID_MP2:
|
238 |
case CODEC_ID_MP3:
|
239 |
stream_type = STREAM_TYPE_AUDIO_MPEG1; |
240 |
break;
|
241 |
case CODEC_ID_AAC:
|
242 |
stream_type = STREAM_TYPE_AUDIO_AAC; |
243 |
break;
|
244 |
case CODEC_ID_AC3:
|
245 |
stream_type = STREAM_TYPE_AUDIO_AC3; |
246 |
break;
|
247 |
default:
|
248 |
stream_type = STREAM_TYPE_PRIVATE_DATA; |
249 |
break;
|
250 |
} |
251 |
*q++ = stream_type; |
252 |
put16(&q, 0xe000 | ts_st->pid);
|
253 |
desc_length_ptr = q; |
254 |
q += 2; /* patched after */ |
255 |
|
256 |
/* write optional descriptors here */
|
257 |
switch(st->codec->codec_type) {
|
258 |
case AVMEDIA_TYPE_AUDIO:
|
259 |
if (lang && strlen(lang->value) == 3) { |
260 |
*q++ = 0x0a; /* ISO 639 language descriptor */ |
261 |
*q++ = 4;
|
262 |
*q++ = lang->value[0];
|
263 |
*q++ = lang->value[1];
|
264 |
*q++ = lang->value[2];
|
265 |
*q++ = 0; /* undefined type */ |
266 |
} |
267 |
break;
|
268 |
case AVMEDIA_TYPE_SUBTITLE:
|
269 |
{ |
270 |
const char *language; |
271 |
language = lang && strlen(lang->value)==3 ? lang->value : "eng"; |
272 |
*q++ = 0x59;
|
273 |
*q++ = 8;
|
274 |
*q++ = language[0];
|
275 |
*q++ = language[1];
|
276 |
*q++ = language[2];
|
277 |
*q++ = 0x10; /* normal subtitles (0x20 = if hearing pb) */ |
278 |
put16(&q, 1); /* page id */ |
279 |
put16(&q, 1); /* ancillary page id */ |
280 |
} |
281 |
break;
|
282 |
case AVMEDIA_TYPE_VIDEO:
|
283 |
if (stream_type == STREAM_TYPE_VIDEO_DIRAC) {
|
284 |
*q++ = 0x05; /*MPEG-2 registration descriptor*/ |
285 |
*q++ = 4;
|
286 |
*q++ = 'd';
|
287 |
*q++ = 'r';
|
288 |
*q++ = 'a';
|
289 |
*q++ = 'c';
|
290 |
} |
291 |
break;
|
292 |
} |
293 |
|
294 |
val = 0xf000 | (q - desc_length_ptr - 2); |
295 |
desc_length_ptr[0] = val >> 8; |
296 |
desc_length_ptr[1] = val;
|
297 |
} |
298 |
mpegts_write_section1(&service->pmt, PMT_TID, service->sid, 0, 0, 0, |
299 |
data, q - data); |
300 |
} |
301 |
|
302 |
/* NOTE: str == NULL is accepted for an empty string */
|
303 |
static void putstr8(uint8_t **q_ptr, const char *str) |
304 |
{ |
305 |
uint8_t *q; |
306 |
int len;
|
307 |
|
308 |
q = *q_ptr; |
309 |
if (!str)
|
310 |
len = 0;
|
311 |
else
|
312 |
len = strlen(str); |
313 |
*q++ = len; |
314 |
memcpy(q, str, len); |
315 |
q += len; |
316 |
*q_ptr = q; |
317 |
} |
318 |
|
319 |
static void mpegts_write_sdt(AVFormatContext *s) |
320 |
{ |
321 |
MpegTSWrite *ts = s->priv_data; |
322 |
MpegTSService *service; |
323 |
uint8_t data[1012], *q, *desc_list_len_ptr, *desc_len_ptr;
|
324 |
int i, running_status, free_ca_mode, val;
|
325 |
|
326 |
q = data; |
327 |
put16(&q, ts->onid); |
328 |
*q++ = 0xff;
|
329 |
for(i = 0; i < ts->nb_services; i++) { |
330 |
service = ts->services[i]; |
331 |
put16(&q, service->sid); |
332 |
*q++ = 0xfc | 0x00; /* currently no EIT info */ |
333 |
desc_list_len_ptr = q; |
334 |
q += 2;
|
335 |
running_status = 4; /* running */ |
336 |
free_ca_mode = 0;
|
337 |
|
338 |
/* write only one descriptor for the service name and provider */
|
339 |
*q++ = 0x48;
|
340 |
desc_len_ptr = q; |
341 |
q++; |
342 |
*q++ = 0x01; /* digital television service */ |
343 |
putstr8(&q, service->provider_name); |
344 |
putstr8(&q, service->name); |
345 |
desc_len_ptr[0] = q - desc_len_ptr - 1; |
346 |
|
347 |
/* fill descriptor length */
|
348 |
val = (running_status << 13) | (free_ca_mode << 12) | |
349 |
(q - desc_list_len_ptr - 2);
|
350 |
desc_list_len_ptr[0] = val >> 8; |
351 |
desc_list_len_ptr[1] = val;
|
352 |
} |
353 |
mpegts_write_section1(&ts->sdt, SDT_TID, ts->tsid, 0, 0, 0, |
354 |
data, q - data); |
355 |
} |
356 |
|
357 |
static MpegTSService *mpegts_add_service(MpegTSWrite *ts,
|
358 |
int sid,
|
359 |
const char *provider_name, |
360 |
const char *name) |
361 |
{ |
362 |
MpegTSService *service; |
363 |
|
364 |
service = av_mallocz(sizeof(MpegTSService));
|
365 |
if (!service)
|
366 |
return NULL; |
367 |
service->pmt.pid = DEFAULT_PMT_START_PID + ts->nb_services - 1;
|
368 |
service->sid = sid; |
369 |
service->provider_name = av_strdup(provider_name); |
370 |
service->name = av_strdup(name); |
371 |
service->pcr_pid = 0x1fff;
|
372 |
dynarray_add(&ts->services, &ts->nb_services, service); |
373 |
return service;
|
374 |
} |
375 |
|
376 |
static void section_write_packet(MpegTSSection *s, const uint8_t *packet) |
377 |
{ |
378 |
AVFormatContext *ctx = s->opaque; |
379 |
put_buffer(ctx->pb, packet, TS_PACKET_SIZE); |
380 |
} |
381 |
|
382 |
static int mpegts_write_header(AVFormatContext *s) |
383 |
{ |
384 |
MpegTSWrite *ts = s->priv_data; |
385 |
MpegTSWriteStream *ts_st; |
386 |
MpegTSService *service; |
387 |
AVStream *st, *pcr_st = NULL;
|
388 |
AVMetadataTag *title; |
389 |
int i;
|
390 |
const char *service_name; |
391 |
|
392 |
ts->tsid = DEFAULT_TSID; |
393 |
ts->onid = DEFAULT_ONID; |
394 |
/* allocate a single DVB service */
|
395 |
title = av_metadata_get(s->metadata, "title", NULL, 0); |
396 |
service_name = title ? title->value : DEFAULT_SERVICE_NAME; |
397 |
service = mpegts_add_service(ts, DEFAULT_SID, |
398 |
DEFAULT_PROVIDER_NAME, service_name); |
399 |
service->pmt.write_packet = section_write_packet; |
400 |
service->pmt.opaque = s; |
401 |
service->pmt.cc = 15;
|
402 |
|
403 |
ts->pat.pid = PAT_PID; |
404 |
ts->pat.cc = 15; // Initialize at 15 so that it wraps and be equal to 0 for the first packet we write |
405 |
ts->pat.write_packet = section_write_packet; |
406 |
ts->pat.opaque = s; |
407 |
|
408 |
ts->sdt.pid = SDT_PID; |
409 |
ts->sdt.cc = 15;
|
410 |
ts->sdt.write_packet = section_write_packet; |
411 |
ts->sdt.opaque = s; |
412 |
|
413 |
/* assign pids to each stream */
|
414 |
for(i = 0;i < s->nb_streams; i++) { |
415 |
st = s->streams[i]; |
416 |
ts_st = av_mallocz(sizeof(MpegTSWriteStream));
|
417 |
if (!ts_st)
|
418 |
goto fail;
|
419 |
st->priv_data = ts_st; |
420 |
ts_st->service = service; |
421 |
ts_st->pid = DEFAULT_START_PID + i; |
422 |
ts_st->payload_pts = AV_NOPTS_VALUE; |
423 |
ts_st->payload_dts = AV_NOPTS_VALUE; |
424 |
ts_st->first_pts_check = 1;
|
425 |
ts_st->cc = 15;
|
426 |
/* update PCR pid by using the first video stream */
|
427 |
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
|
428 |
service->pcr_pid == 0x1fff) {
|
429 |
service->pcr_pid = ts_st->pid; |
430 |
pcr_st = st; |
431 |
} |
432 |
if (st->codec->codec_id == CODEC_ID_AAC &&
|
433 |
st->codec->extradata_size > 0) {
|
434 |
ts_st->adts = av_mallocz(sizeof(*ts_st->adts));
|
435 |
if (!ts_st->adts)
|
436 |
return AVERROR(ENOMEM);
|
437 |
if (ff_adts_decode_extradata(s, ts_st->adts, st->codec->extradata,
|
438 |
st->codec->extradata_size) < 0)
|
439 |
return -1; |
440 |
} |
441 |
} |
442 |
|
443 |
/* if no video stream, use the first stream as PCR */
|
444 |
if (service->pcr_pid == 0x1fff && s->nb_streams > 0) { |
445 |
pcr_st = s->streams[0];
|
446 |
ts_st = pcr_st->priv_data; |
447 |
service->pcr_pid = ts_st->pid; |
448 |
} |
449 |
|
450 |
ts->mux_rate = s->mux_rate ? s->mux_rate : 1;
|
451 |
|
452 |
if (ts->mux_rate > 1) { |
453 |
service->pcr_packet_period = (ts->mux_rate * PCR_RETRANS_TIME) / |
454 |
(TS_PACKET_SIZE * 8 * 1000); |
455 |
ts->sdt_packet_period = (ts->mux_rate * SDT_RETRANS_TIME) / |
456 |
(TS_PACKET_SIZE * 8 * 1000); |
457 |
ts->pat_packet_period = (ts->mux_rate * PAT_RETRANS_TIME) / |
458 |
(TS_PACKET_SIZE * 8 * 1000); |
459 |
|
460 |
ts->cur_pcr = av_rescale(s->max_delay, 90000, AV_TIME_BASE);
|
461 |
} else {
|
462 |
/* Arbitrary values, PAT/PMT could be written on key frames */
|
463 |
ts->sdt_packet_period = 200;
|
464 |
ts->pat_packet_period = 40;
|
465 |
if (pcr_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
|
466 |
if (!pcr_st->codec->frame_size) {
|
467 |
av_log(s, AV_LOG_WARNING, "frame size not set\n");
|
468 |
service->pcr_packet_period = |
469 |
pcr_st->codec->sample_rate/(10*512); |
470 |
} else {
|
471 |
service->pcr_packet_period = |
472 |
pcr_st->codec->sample_rate/(10*pcr_st->codec->frame_size);
|
473 |
} |
474 |
} else {
|
475 |
// max delta PCR 0.1s
|
476 |
service->pcr_packet_period = |
477 |
pcr_st->codec->time_base.den/(10*pcr_st->codec->time_base.num);
|
478 |
} |
479 |
} |
480 |
|
481 |
// output a PCR as soon as possible
|
482 |
service->pcr_packet_count = service->pcr_packet_period; |
483 |
ts->pat_packet_count = ts->pat_packet_period-1;
|
484 |
ts->sdt_packet_count = ts->sdt_packet_period-1;
|
485 |
|
486 |
av_log(s, AV_LOG_INFO, |
487 |
"muxrate %d bps, pcr every %d pkts, "
|
488 |
"sdt every %d, pat/pmt every %d pkts\n",
|
489 |
ts->mux_rate, service->pcr_packet_period, |
490 |
ts->sdt_packet_period, ts->pat_packet_period); |
491 |
|
492 |
|
493 |
put_flush_packet(s->pb); |
494 |
|
495 |
return 0; |
496 |
|
497 |
fail:
|
498 |
for(i = 0;i < s->nb_streams; i++) { |
499 |
st = s->streams[i]; |
500 |
av_free(st->priv_data); |
501 |
} |
502 |
return -1; |
503 |
} |
504 |
|
505 |
/* send SDT, PAT and PMT tables regulary */
|
506 |
static void retransmit_si_info(AVFormatContext *s) |
507 |
{ |
508 |
MpegTSWrite *ts = s->priv_data; |
509 |
int i;
|
510 |
|
511 |
if (++ts->sdt_packet_count == ts->sdt_packet_period) {
|
512 |
ts->sdt_packet_count = 0;
|
513 |
mpegts_write_sdt(s); |
514 |
} |
515 |
if (++ts->pat_packet_count == ts->pat_packet_period) {
|
516 |
ts->pat_packet_count = 0;
|
517 |
mpegts_write_pat(s); |
518 |
for(i = 0; i < ts->nb_services; i++) { |
519 |
mpegts_write_pmt(s, ts->services[i]); |
520 |
} |
521 |
} |
522 |
} |
523 |
|
524 |
/* Write a single null transport stream packet */
|
525 |
static void mpegts_insert_null_packet(AVFormatContext *s) |
526 |
{ |
527 |
MpegTSWrite *ts = s->priv_data; |
528 |
uint8_t *q; |
529 |
uint8_t buf[TS_PACKET_SIZE]; |
530 |
|
531 |
q = buf; |
532 |
*q++ = 0x47;
|
533 |
*q++ = 0x00 | 0x1f; |
534 |
*q++ = 0xff;
|
535 |
*q++ = 0x10;
|
536 |
memset(q, 0x0FF, TS_PACKET_SIZE - (q - buf));
|
537 |
put_buffer(s->pb, buf, TS_PACKET_SIZE); |
538 |
ts->cur_pcr += TS_PACKET_SIZE*8*90000LL/ts->mux_rate; |
539 |
} |
540 |
|
541 |
/* Write a single transport stream packet with a PCR and no payload */
|
542 |
static void mpegts_insert_pcr_only(AVFormatContext *s, AVStream *st) |
543 |
{ |
544 |
MpegTSWrite *ts = s->priv_data; |
545 |
MpegTSWriteStream *ts_st = st->priv_data; |
546 |
uint8_t *q; |
547 |
uint64_t pcr = ts->cur_pcr; |
548 |
uint8_t buf[TS_PACKET_SIZE]; |
549 |
|
550 |
q = buf; |
551 |
*q++ = 0x47;
|
552 |
*q++ = ts_st->pid >> 8;
|
553 |
*q++ = ts_st->pid; |
554 |
*q++ = 0x20 | ts_st->cc; /* Adaptation only */ |
555 |
/* Continuity Count field does not increment (see 13818-1 section 2.4.3.3) */
|
556 |
*q++ = TS_PACKET_SIZE - 5; /* Adaptation Field Length */ |
557 |
*q++ = 0x10; /* Adaptation flags: PCR present */ |
558 |
|
559 |
/* PCR coded into 6 bytes */
|
560 |
*q++ = pcr >> 25;
|
561 |
*q++ = pcr >> 17;
|
562 |
*q++ = pcr >> 9;
|
563 |
*q++ = pcr >> 1;
|
564 |
*q++ = (pcr & 1) << 7; |
565 |
*q++ = 0;
|
566 |
|
567 |
/* stuffing bytes */
|
568 |
memset(q, 0xFF, TS_PACKET_SIZE - (q - buf));
|
569 |
put_buffer(s->pb, buf, TS_PACKET_SIZE); |
570 |
ts->cur_pcr += TS_PACKET_SIZE*8*90000LL/ts->mux_rate; |
571 |
} |
572 |
|
573 |
static void write_pts(uint8_t *q, int fourbits, int64_t pts) |
574 |
{ |
575 |
int val;
|
576 |
|
577 |
val = fourbits << 4 | (((pts >> 30) & 0x07) << 1) | 1; |
578 |
*q++ = val; |
579 |
val = (((pts >> 15) & 0x7fff) << 1) | 1; |
580 |
*q++ = val >> 8;
|
581 |
*q++ = val; |
582 |
val = (((pts) & 0x7fff) << 1) | 1; |
583 |
*q++ = val >> 8;
|
584 |
*q++ = val; |
585 |
} |
586 |
|
587 |
/* Add a pes header to the front of payload, and segment into an integer number of
|
588 |
* ts packets. The final ts packet is padded using an over-sized adaptation header
|
589 |
* to exactly fill the last ts packet.
|
590 |
* NOTE: 'payload' contains a complete PES payload.
|
591 |
*/
|
592 |
static void mpegts_write_pes(AVFormatContext *s, AVStream *st, |
593 |
const uint8_t *payload, int payload_size, |
594 |
int64_t pts, int64_t dts) |
595 |
{ |
596 |
MpegTSWriteStream *ts_st = st->priv_data; |
597 |
MpegTSWrite *ts = s->priv_data; |
598 |
uint8_t buf[TS_PACKET_SIZE]; |
599 |
uint8_t *q; |
600 |
int val, is_start, len, header_len, write_pcr, private_code, flags;
|
601 |
int afc_len, stuffing_len;
|
602 |
int64_t pcr = -1; /* avoid warning */ |
603 |
int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE);
|
604 |
|
605 |
is_start = 1;
|
606 |
while (payload_size > 0) { |
607 |
retransmit_si_info(s); |
608 |
|
609 |
write_pcr = 0;
|
610 |
if (ts_st->pid == ts_st->service->pcr_pid) {
|
611 |
if (ts->mux_rate > 1 || is_start) // VBR pcr period is based on frames |
612 |
ts_st->service->pcr_packet_count++; |
613 |
if (ts_st->service->pcr_packet_count >=
|
614 |
ts_st->service->pcr_packet_period) { |
615 |
ts_st->service->pcr_packet_count = 0;
|
616 |
write_pcr = 1;
|
617 |
} |
618 |
} |
619 |
|
620 |
if (ts->mux_rate > 1 && dts != AV_NOPTS_VALUE && |
621 |
(dts - (int64_t)ts->cur_pcr) > delay) { |
622 |
/* pcr insert gets priority over null packet insert */
|
623 |
if (write_pcr)
|
624 |
mpegts_insert_pcr_only(s, st); |
625 |
else
|
626 |
mpegts_insert_null_packet(s); |
627 |
continue; /* recalculate write_pcr and possibly retransmit si_info */ |
628 |
} |
629 |
|
630 |
/* prepare packet header */
|
631 |
q = buf; |
632 |
*q++ = 0x47;
|
633 |
val = (ts_st->pid >> 8);
|
634 |
if (is_start)
|
635 |
val |= 0x40;
|
636 |
*q++ = val; |
637 |
*q++ = ts_st->pid; |
638 |
ts_st->cc = (ts_st->cc + 1) & 0xf; |
639 |
*q++ = 0x10 | ts_st->cc | (write_pcr ? 0x20 : 0); |
640 |
if (write_pcr) {
|
641 |
// add 11, pcr references the last byte of program clock reference base
|
642 |
if (ts->mux_rate > 1) |
643 |
pcr = ts->cur_pcr + (4+7)*8*90000LL / ts->mux_rate; |
644 |
else
|
645 |
pcr = dts - delay; |
646 |
if (dts != AV_NOPTS_VALUE && dts < pcr)
|
647 |
av_log(s, AV_LOG_WARNING, "dts < pcr, TS is invalid\n");
|
648 |
*q++ = 7; /* AFC length */ |
649 |
*q++ = 0x10; /* flags: PCR present */ |
650 |
*q++ = pcr >> 25;
|
651 |
*q++ = pcr >> 17;
|
652 |
*q++ = pcr >> 9;
|
653 |
*q++ = pcr >> 1;
|
654 |
*q++ = (pcr & 1) << 7; |
655 |
*q++ = 0;
|
656 |
} |
657 |
if (is_start) {
|
658 |
int pes_extension = 0; |
659 |
/* write PES header */
|
660 |
*q++ = 0x00;
|
661 |
*q++ = 0x00;
|
662 |
*q++ = 0x01;
|
663 |
private_code = 0;
|
664 |
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
|
665 |
if (st->codec->codec_id == CODEC_ID_DIRAC) {
|
666 |
*q++ = 0xfd;
|
667 |
} else
|
668 |
*q++ = 0xe0;
|
669 |
} else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && |
670 |
(st->codec->codec_id == CODEC_ID_MP2 || |
671 |
st->codec->codec_id == CODEC_ID_MP3)) { |
672 |
*q++ = 0xc0;
|
673 |
} else {
|
674 |
*q++ = 0xbd;
|
675 |
if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
|
676 |
private_code = 0x20;
|
677 |
} |
678 |
} |
679 |
header_len = 0;
|
680 |
flags = 0;
|
681 |
if (pts != AV_NOPTS_VALUE) {
|
682 |
header_len += 5;
|
683 |
flags |= 0x80;
|
684 |
} |
685 |
if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
|
686 |
header_len += 5;
|
687 |
flags |= 0x40;
|
688 |
} |
689 |
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
|
690 |
st->codec->codec_id == CODEC_ID_DIRAC) { |
691 |
/* set PES_extension_flag */
|
692 |
pes_extension = 1;
|
693 |
flags |= 0x01;
|
694 |
|
695 |
/*
|
696 |
* One byte for PES2 extension flag +
|
697 |
* one byte for extension length +
|
698 |
* one byte for extension id
|
699 |
*/
|
700 |
header_len += 3;
|
701 |
} |
702 |
len = payload_size + header_len + 3;
|
703 |
if (private_code != 0) |
704 |
len++; |
705 |
if (len > 0xffff) |
706 |
len = 0;
|
707 |
*q++ = len >> 8;
|
708 |
*q++ = len; |
709 |
val = 0x80;
|
710 |
/* data alignment indicator is required for subtitle data */
|
711 |
if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
|
712 |
val |= 0x04;
|
713 |
*q++ = val; |
714 |
*q++ = flags; |
715 |
*q++ = header_len; |
716 |
if (pts != AV_NOPTS_VALUE) {
|
717 |
write_pts(q, flags >> 6, pts);
|
718 |
q += 5;
|
719 |
} |
720 |
if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
|
721 |
write_pts(q, 1, dts);
|
722 |
q += 5;
|
723 |
} |
724 |
if (pes_extension && st->codec->codec_id == CODEC_ID_DIRAC) {
|
725 |
flags = 0x01; /* set PES_extension_flag_2 */ |
726 |
*q++ = flags; |
727 |
*q++ = 0x80 | 0x01; /* marker bit + extension length */ |
728 |
/*
|
729 |
* Set the stream id extension flag bit to 0 and
|
730 |
* write the extended stream id
|
731 |
*/
|
732 |
*q++ = 0x00 | 0x60; |
733 |
} |
734 |
if (private_code != 0) |
735 |
*q++ = private_code; |
736 |
is_start = 0;
|
737 |
} |
738 |
/* header size */
|
739 |
header_len = q - buf; |
740 |
/* data len */
|
741 |
len = TS_PACKET_SIZE - header_len; |
742 |
if (len > payload_size)
|
743 |
len = payload_size; |
744 |
stuffing_len = TS_PACKET_SIZE - header_len - len; |
745 |
if (stuffing_len > 0) { |
746 |
/* add stuffing with AFC */
|
747 |
if (buf[3] & 0x20) { |
748 |
/* stuffing already present: increase its size */
|
749 |
afc_len = buf[4] + 1; |
750 |
memmove(buf + 4 + afc_len + stuffing_len,
|
751 |
buf + 4 + afc_len,
|
752 |
header_len - (4 + afc_len));
|
753 |
buf[4] += stuffing_len;
|
754 |
memset(buf + 4 + afc_len, 0xff, stuffing_len); |
755 |
} else {
|
756 |
/* add stuffing */
|
757 |
memmove(buf + 4 + stuffing_len, buf + 4, header_len - 4); |
758 |
buf[3] |= 0x20; |
759 |
buf[4] = stuffing_len - 1; |
760 |
if (stuffing_len >= 2) { |
761 |
buf[5] = 0x00; |
762 |
memset(buf + 6, 0xff, stuffing_len - 2); |
763 |
} |
764 |
} |
765 |
} |
766 |
memcpy(buf + TS_PACKET_SIZE - len, payload, len); |
767 |
payload += len; |
768 |
payload_size -= len; |
769 |
put_buffer(s->pb, buf, TS_PACKET_SIZE); |
770 |
ts->cur_pcr += TS_PACKET_SIZE*8*90000LL/ts->mux_rate; |
771 |
} |
772 |
put_flush_packet(s->pb); |
773 |
} |
774 |
|
775 |
static int mpegts_write_packet(AVFormatContext *s, AVPacket *pkt) |
776 |
{ |
777 |
AVStream *st = s->streams[pkt->stream_index]; |
778 |
int size = pkt->size;
|
779 |
uint8_t *buf= pkt->data; |
780 |
uint8_t *data= NULL;
|
781 |
MpegTSWriteStream *ts_st = st->priv_data; |
782 |
const uint64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE)*2; |
783 |
int64_t dts = AV_NOPTS_VALUE, pts = AV_NOPTS_VALUE; |
784 |
|
785 |
if (pkt->pts != AV_NOPTS_VALUE)
|
786 |
pts = pkt->pts + delay; |
787 |
if (pkt->dts != AV_NOPTS_VALUE)
|
788 |
dts = pkt->dts + delay; |
789 |
|
790 |
if (ts_st->first_pts_check && pts == AV_NOPTS_VALUE) {
|
791 |
av_log(s, AV_LOG_ERROR, "first pts value must set\n");
|
792 |
return -1; |
793 |
} |
794 |
ts_st->first_pts_check = 0;
|
795 |
|
796 |
if (st->codec->codec_id == CODEC_ID_H264) {
|
797 |
const uint8_t *p = buf, *buf_end = p+size;
|
798 |
uint32_t state = -1;
|
799 |
|
800 |
if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001) { |
801 |
av_log(s, AV_LOG_ERROR, "h264 bitstream malformated, "
|
802 |
"no startcode found, use -vbsf h264_mp4toannexb\n");
|
803 |
return -1; |
804 |
} |
805 |
|
806 |
do {
|
807 |
p = ff_find_start_code(p, buf_end, &state); |
808 |
//av_log(s, AV_LOG_INFO, "nal %d\n", state & 0x1f);
|
809 |
} while (p < buf_end && (state & 0x1f) != 9 && |
810 |
(state & 0x1f) != 5 && (state & 0x1f) != 1); |
811 |
|
812 |
if ((state & 0x1f) != 9) { // AUD NAL |
813 |
data = av_malloc(pkt->size+6);
|
814 |
if (!data)
|
815 |
return -1; |
816 |
memcpy(data+6, pkt->data, pkt->size);
|
817 |
AV_WB32(data, 0x00000001);
|
818 |
data[4] = 0x09; |
819 |
data[5] = 0xe0; // any slice type |
820 |
buf = data; |
821 |
size = pkt->size+6;
|
822 |
} |
823 |
} else if (st->codec->codec_id == CODEC_ID_AAC) { |
824 |
if (pkt->size < 2) |
825 |
return -1; |
826 |
if ((AV_RB16(pkt->data) & 0xfff0) != 0xfff0) { |
827 |
ADTSContext *adts = ts_st->adts; |
828 |
int new_size;
|
829 |
if (!adts) {
|
830 |
av_log(s, AV_LOG_ERROR, "aac bitstream not in adts format "
|
831 |
"and extradata missing\n");
|
832 |
return -1; |
833 |
} |
834 |
new_size = ADTS_HEADER_SIZE+adts->pce_size+pkt->size; |
835 |
if ((unsigned)new_size >= INT_MAX) |
836 |
return -1; |
837 |
data = av_malloc(new_size); |
838 |
if (!data)
|
839 |
return AVERROR(ENOMEM);
|
840 |
ff_adts_write_frame_header(adts, data, pkt->size, adts->pce_size); |
841 |
if (adts->pce_size) {
|
842 |
memcpy(data+ADTS_HEADER_SIZE, adts->pce_data, adts->pce_size); |
843 |
adts->pce_size = 0;
|
844 |
} |
845 |
memcpy(data+ADTS_HEADER_SIZE+adts->pce_size, pkt->data, pkt->size); |
846 |
buf = data; |
847 |
size = new_size; |
848 |
} |
849 |
} |
850 |
|
851 |
if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
|
852 |
// for video and subtitle, write a single pes packet
|
853 |
mpegts_write_pes(s, st, buf, size, pts, dts); |
854 |
av_free(data); |
855 |
return 0; |
856 |
} |
857 |
|
858 |
if (ts_st->payload_index + size > DEFAULT_PES_PAYLOAD_SIZE) {
|
859 |
mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_index, |
860 |
ts_st->payload_pts, ts_st->payload_dts); |
861 |
ts_st->payload_index = 0;
|
862 |
} |
863 |
|
864 |
if (!ts_st->payload_index) {
|
865 |
ts_st->payload_pts = pts; |
866 |
ts_st->payload_dts = dts; |
867 |
} |
868 |
|
869 |
memcpy(ts_st->payload + ts_st->payload_index, buf, size); |
870 |
ts_st->payload_index += size; |
871 |
|
872 |
av_free(data); |
873 |
|
874 |
return 0; |
875 |
} |
876 |
|
877 |
static int mpegts_write_end(AVFormatContext *s) |
878 |
{ |
879 |
MpegTSWrite *ts = s->priv_data; |
880 |
MpegTSWriteStream *ts_st; |
881 |
MpegTSService *service; |
882 |
AVStream *st; |
883 |
int i;
|
884 |
|
885 |
/* flush current packets */
|
886 |
for(i = 0; i < s->nb_streams; i++) { |
887 |
st = s->streams[i]; |
888 |
ts_st = st->priv_data; |
889 |
if (ts_st->payload_index > 0) { |
890 |
mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_index, |
891 |
ts_st->payload_pts, ts_st->payload_dts); |
892 |
} |
893 |
av_freep(&ts_st->adts); |
894 |
} |
895 |
put_flush_packet(s->pb); |
896 |
|
897 |
for(i = 0; i < ts->nb_services; i++) { |
898 |
service = ts->services[i]; |
899 |
av_freep(&service->provider_name); |
900 |
av_freep(&service->name); |
901 |
av_free(service); |
902 |
} |
903 |
av_free(ts->services); |
904 |
|
905 |
return 0; |
906 |
} |
907 |
|
908 |
AVOutputFormat mpegts_muxer = { |
909 |
"mpegts",
|
910 |
NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
|
911 |
"video/x-mpegts",
|
912 |
"ts,m2t",
|
913 |
sizeof(MpegTSWrite),
|
914 |
CODEC_ID_MP2, |
915 |
CODEC_ID_MPEG2VIDEO, |
916 |
mpegts_write_header, |
917 |
mpegts_write_packet, |
918 |
mpegts_write_end, |
919 |
}; |