00001 /* 00002 * MPEG2 transport stream (aka DVB) muxer 00003 * Copyright (c) 2003 Fabrice Bellard 00004 * 00005 * This file is part of FFmpeg. 00006 * 00007 * FFmpeg is free software; you can redistribute it and/or 00008 * modify it under the terms of the GNU Lesser General Public 00009 * License as published by the Free Software Foundation; either 00010 * version 2.1 of the License, or (at your option) any later version. 00011 * 00012 * FFmpeg is distributed in the hope that it will be useful, 00013 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00015 * Lesser General Public License for more details. 00016 * 00017 * You should have received a copy of the GNU Lesser General Public 00018 * License along with FFmpeg; if not, write to the Free Software 00019 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 00020 */ 00021 00022 #include "libavutil/bswap.h" 00023 #include "libavutil/crc.h" 00024 #include "libavutil/dict.h" 00025 #include "libavutil/mathematics.h" 00026 #include "libavutil/opt.h" 00027 #include "libavutil/avassert.h" 00028 #include "libavcodec/mpegvideo.h" 00029 #include "avformat.h" 00030 #include "internal.h" 00031 #include "mpegts.h" 00032 #include "adts.h" 00033 00034 #define PCR_TIME_BASE 27000000 00035 00036 /* write DVB SI sections */ 00037 00038 /*********************************************/ 00039 /* mpegts section writer */ 00040 00041 typedef struct MpegTSSection { 00042 int pid; 00043 int cc; 00044 void (*write_packet)(struct MpegTSSection *s, const uint8_t *packet); 00045 void *opaque; 00046 } MpegTSSection; 00047 00048 typedef struct MpegTSService { 00049 MpegTSSection pmt; /* MPEG2 pmt table context */ 00050 int sid; /* service ID */ 00051 char *name; 00052 char *provider_name; 00053 int pcr_pid; 00054 int pcr_packet_count; 00055 int pcr_packet_period; 00056 } MpegTSService; 00057 00058 typedef struct MpegTSWrite { 00059 const AVClass *av_class; 00060 MpegTSSection pat; /* MPEG2 pat table */ 00061 MpegTSSection sdt; /* MPEG2 sdt table context */ 00062 MpegTSService **services; 00063 int sdt_packet_count; 00064 int sdt_packet_period; 00065 int pat_packet_count; 00066 int pat_packet_period; 00067 int nb_services; 00068 int onid; 00069 int tsid; 00070 int64_t first_pcr; 00071 int mux_rate; 00072 int pes_payload_size; 00073 00074 int transport_stream_id; 00075 int original_network_id; 00076 int service_id; 00077 00078 int pmt_start_pid; 00079 int start_pid; 00080 int m2ts_mode; 00081 } MpegTSWrite; 00082 00083 /* a PES packet header is generated every DEFAULT_PES_HEADER_FREQ packets */ 00084 #define DEFAULT_PES_HEADER_FREQ 16 00085 #define DEFAULT_PES_PAYLOAD_SIZE ((DEFAULT_PES_HEADER_FREQ - 1) * 184 + 170) 00086 00087 static const AVOption options[] = { 00088 { "mpegts_transport_stream_id", "Set transport_stream_id field.", 00089 offsetof(MpegTSWrite, transport_stream_id), AV_OPT_TYPE_INT, {.dbl = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM}, 00090 { "mpegts_original_network_id", "Set original_network_id field.", 00091 offsetof(MpegTSWrite, original_network_id), AV_OPT_TYPE_INT, {.dbl = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM}, 00092 { "mpegts_service_id", "Set service_id field.", 00093 offsetof(MpegTSWrite, service_id), AV_OPT_TYPE_INT, {.dbl = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM}, 00094 { "mpegts_pmt_start_pid", "Set the first pid of the PMT.", 00095 offsetof(MpegTSWrite, pmt_start_pid), AV_OPT_TYPE_INT, {.dbl = 0x1000 }, 0x0010, 0x1f00, AV_OPT_FLAG_ENCODING_PARAM}, 00096 { "mpegts_start_pid", "Set the first pid.", 00097 offsetof(MpegTSWrite, start_pid), AV_OPT_TYPE_INT, {.dbl = 0x0100 }, 0x0100, 0x0f00, AV_OPT_FLAG_ENCODING_PARAM}, 00098 {"mpegts_m2ts_mode", "Enable m2ts mode.", 00099 offsetof(MpegTSWrite, m2ts_mode), AV_OPT_TYPE_INT, {.dbl = -1 }, 00100 -1,1, AV_OPT_FLAG_ENCODING_PARAM}, 00101 { "muxrate", NULL, offsetof(MpegTSWrite, mux_rate), AV_OPT_TYPE_INT, {1}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM}, 00102 { "pes_payload_size", "Minimum PES packet payload in bytes", 00103 offsetof(MpegTSWrite, pes_payload_size), AV_OPT_TYPE_INT, {DEFAULT_PES_PAYLOAD_SIZE}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM}, 00104 { NULL }, 00105 }; 00106 00107 static const AVClass mpegts_muxer_class = { 00108 .class_name = "MPEGTS muxer", 00109 .item_name = av_default_item_name, 00110 .option = options, 00111 .version = LIBAVUTIL_VERSION_INT, 00112 }; 00113 00114 /* NOTE: 4 bytes must be left at the end for the crc32 */ 00115 static void mpegts_write_section(MpegTSSection *s, uint8_t *buf, int len) 00116 { 00117 unsigned int crc; 00118 unsigned char packet[TS_PACKET_SIZE]; 00119 const unsigned char *buf_ptr; 00120 unsigned char *q; 00121 int first, b, len1, left; 00122 00123 crc = av_bswap32(av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, buf, len - 4)); 00124 buf[len - 4] = (crc >> 24) & 0xff; 00125 buf[len - 3] = (crc >> 16) & 0xff; 00126 buf[len - 2] = (crc >> 8) & 0xff; 00127 buf[len - 1] = (crc) & 0xff; 00128 00129 /* send each packet */ 00130 buf_ptr = buf; 00131 while (len > 0) { 00132 first = (buf == buf_ptr); 00133 q = packet; 00134 *q++ = 0x47; 00135 b = (s->pid >> 8); 00136 if (first) 00137 b |= 0x40; 00138 *q++ = b; 00139 *q++ = s->pid; 00140 s->cc = (s->cc + 1) & 0xf; 00141 *q++ = 0x10 | s->cc; 00142 if (first) 00143 *q++ = 0; /* 0 offset */ 00144 len1 = TS_PACKET_SIZE - (q - packet); 00145 if (len1 > len) 00146 len1 = len; 00147 memcpy(q, buf_ptr, len1); 00148 q += len1; 00149 /* add known padding data */ 00150 left = TS_PACKET_SIZE - (q - packet); 00151 if (left > 0) 00152 memset(q, 0xff, left); 00153 00154 s->write_packet(s, packet); 00155 00156 buf_ptr += len1; 00157 len -= len1; 00158 } 00159 } 00160 00161 static inline void put16(uint8_t **q_ptr, int val) 00162 { 00163 uint8_t *q; 00164 q = *q_ptr; 00165 *q++ = val >> 8; 00166 *q++ = val; 00167 *q_ptr = q; 00168 } 00169 00170 static int mpegts_write_section1(MpegTSSection *s, int tid, int id, 00171 int version, int sec_num, int last_sec_num, 00172 uint8_t *buf, int len) 00173 { 00174 uint8_t section[1024], *q; 00175 unsigned int tot_len; 00176 /* reserved_future_use field must be set to 1 for SDT */ 00177 unsigned int flags = tid == SDT_TID ? 0xf000 : 0xb000; 00178 00179 tot_len = 3 + 5 + len + 4; 00180 /* check if not too big */ 00181 if (tot_len > 1024) 00182 return AVERROR_INVALIDDATA; 00183 00184 q = section; 00185 *q++ = tid; 00186 put16(&q, flags | (len + 5 + 4)); /* 5 byte header + 4 byte CRC */ 00187 put16(&q, id); 00188 *q++ = 0xc1 | (version << 1); /* current_next_indicator = 1 */ 00189 *q++ = sec_num; 00190 *q++ = last_sec_num; 00191 memcpy(q, buf, len); 00192 00193 mpegts_write_section(s, section, tot_len); 00194 return 0; 00195 } 00196 00197 /*********************************************/ 00198 /* mpegts writer */ 00199 00200 #define DEFAULT_PROVIDER_NAME "FFmpeg" 00201 #define DEFAULT_SERVICE_NAME "Service01" 00202 00203 /* we retransmit the SI info at this rate */ 00204 #define SDT_RETRANS_TIME 500 00205 #define PAT_RETRANS_TIME 100 00206 #define PCR_RETRANS_TIME 20 00207 00208 typedef struct MpegTSWriteStream { 00209 struct MpegTSService *service; 00210 int pid; /* stream associated pid */ 00211 int cc; 00212 int payload_size; 00213 int first_pts_check; 00214 int64_t payload_pts; 00215 int64_t payload_dts; 00216 int payload_flags; 00217 uint8_t *payload; 00218 ADTSContext *adts; 00219 } MpegTSWriteStream; 00220 00221 static void mpegts_write_pat(AVFormatContext *s) 00222 { 00223 MpegTSWrite *ts = s->priv_data; 00224 MpegTSService *service; 00225 uint8_t data[1012], *q; 00226 int i; 00227 00228 q = data; 00229 for(i = 0; i < ts->nb_services; i++) { 00230 service = ts->services[i]; 00231 put16(&q, service->sid); 00232 put16(&q, 0xe000 | service->pmt.pid); 00233 } 00234 mpegts_write_section1(&ts->pat, PAT_TID, ts->tsid, 0, 0, 0, 00235 data, q - data); 00236 } 00237 00238 static void mpegts_write_pmt(AVFormatContext *s, MpegTSService *service) 00239 { 00240 // MpegTSWrite *ts = s->priv_data; 00241 uint8_t data[1012], *q, *desc_length_ptr, *program_info_length_ptr; 00242 int val, stream_type, i; 00243 00244 q = data; 00245 put16(&q, 0xe000 | service->pcr_pid); 00246 00247 program_info_length_ptr = q; 00248 q += 2; /* patched after */ 00249 00250 /* put program info here */ 00251 00252 val = 0xf000 | (q - program_info_length_ptr - 2); 00253 program_info_length_ptr[0] = val >> 8; 00254 program_info_length_ptr[1] = val; 00255 00256 for(i = 0; i < s->nb_streams; i++) { 00257 AVStream *st = s->streams[i]; 00258 MpegTSWriteStream *ts_st = st->priv_data; 00259 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL,0); 00260 switch(st->codec->codec_id) { 00261 case CODEC_ID_MPEG1VIDEO: 00262 case CODEC_ID_MPEG2VIDEO: 00263 stream_type = STREAM_TYPE_VIDEO_MPEG2; 00264 break; 00265 case CODEC_ID_MPEG4: 00266 stream_type = STREAM_TYPE_VIDEO_MPEG4; 00267 break; 00268 case CODEC_ID_H264: 00269 stream_type = STREAM_TYPE_VIDEO_H264; 00270 break; 00271 case CODEC_ID_DIRAC: 00272 stream_type = STREAM_TYPE_VIDEO_DIRAC; 00273 break; 00274 case CODEC_ID_MP2: 00275 case CODEC_ID_MP3: 00276 stream_type = STREAM_TYPE_AUDIO_MPEG1; 00277 break; 00278 case CODEC_ID_AAC: 00279 stream_type = STREAM_TYPE_AUDIO_AAC; 00280 break; 00281 case CODEC_ID_AAC_LATM: 00282 stream_type = STREAM_TYPE_AUDIO_AAC_LATM; 00283 break; 00284 case CODEC_ID_AC3: 00285 stream_type = STREAM_TYPE_AUDIO_AC3; 00286 break; 00287 default: 00288 stream_type = STREAM_TYPE_PRIVATE_DATA; 00289 break; 00290 } 00291 *q++ = stream_type; 00292 put16(&q, 0xe000 | ts_st->pid); 00293 desc_length_ptr = q; 00294 q += 2; /* patched after */ 00295 00296 /* write optional descriptors here */ 00297 switch(st->codec->codec_type) { 00298 case AVMEDIA_TYPE_AUDIO: 00299 if(st->codec->codec_id==CODEC_ID_EAC3){ 00300 *q++=0x7a; // EAC3 descriptor see A038 DVB SI 00301 *q++=1; // 1 byte, all flags sets to 0 00302 *q++=0; // omit all fields... 00303 } 00304 00305 if (lang) { 00306 char *p; 00307 char *next = lang->value; 00308 uint8_t *len_ptr; 00309 00310 *q++ = 0x0a; /* ISO 639 language descriptor */ 00311 len_ptr = q++; 00312 *len_ptr = 0; 00313 00314 for (p = lang->value; next && *len_ptr < 255 / 4 * 4; p = next + 1) { 00315 next = strchr(p, ','); 00316 if (strlen(p) != 3 && (!next || next != p + 3)) 00317 continue; /* not a 3-letter code */ 00318 00319 *q++ = *p++; 00320 *q++ = *p++; 00321 *q++ = *p++; 00322 00323 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS) 00324 *q++ = 0x01; 00325 else if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED) 00326 *q++ = 0x02; 00327 else if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED) 00328 *q++ = 0x03; 00329 else 00330 *q++ = 0; /* undefined type */ 00331 00332 *len_ptr += 4; 00333 } 00334 00335 if (*len_ptr == 0) 00336 q -= 2; /* no language codes were written */ 00337 } 00338 break; 00339 case AVMEDIA_TYPE_SUBTITLE: 00340 { 00341 const char *language; 00342 language = lang && strlen(lang->value)==3 ? lang->value : "eng"; 00343 *q++ = 0x59; 00344 *q++ = 8; 00345 *q++ = language[0]; 00346 *q++ = language[1]; 00347 *q++ = language[2]; 00348 *q++ = 0x10; /* normal subtitles (0x20 = if hearing pb) */ 00349 if(st->codec->extradata_size == 4) { 00350 memcpy(q, st->codec->extradata, 4); 00351 q += 4; 00352 } else { 00353 put16(&q, 1); /* page id */ 00354 put16(&q, 1); /* ancillary page id */ 00355 } 00356 } 00357 break; 00358 case AVMEDIA_TYPE_VIDEO: 00359 if (stream_type == STREAM_TYPE_VIDEO_DIRAC) { 00360 *q++ = 0x05; /*MPEG-2 registration descriptor*/ 00361 *q++ = 4; 00362 *q++ = 'd'; 00363 *q++ = 'r'; 00364 *q++ = 'a'; 00365 *q++ = 'c'; 00366 } 00367 break; 00368 } 00369 00370 val = 0xf000 | (q - desc_length_ptr - 2); 00371 desc_length_ptr[0] = val >> 8; 00372 desc_length_ptr[1] = val; 00373 } 00374 mpegts_write_section1(&service->pmt, PMT_TID, service->sid, 0, 0, 0, 00375 data, q - data); 00376 } 00377 00378 /* NOTE: str == NULL is accepted for an empty string */ 00379 static void putstr8(uint8_t **q_ptr, const char *str) 00380 { 00381 uint8_t *q; 00382 int len; 00383 00384 q = *q_ptr; 00385 if (!str) 00386 len = 0; 00387 else 00388 len = strlen(str); 00389 *q++ = len; 00390 memcpy(q, str, len); 00391 q += len; 00392 *q_ptr = q; 00393 } 00394 00395 static void mpegts_write_sdt(AVFormatContext *s) 00396 { 00397 MpegTSWrite *ts = s->priv_data; 00398 MpegTSService *service; 00399 uint8_t data[1012], *q, *desc_list_len_ptr, *desc_len_ptr; 00400 int i, running_status, free_ca_mode, val; 00401 00402 q = data; 00403 put16(&q, ts->onid); 00404 *q++ = 0xff; 00405 for(i = 0; i < ts->nb_services; i++) { 00406 service = ts->services[i]; 00407 put16(&q, service->sid); 00408 *q++ = 0xfc | 0x00; /* currently no EIT info */ 00409 desc_list_len_ptr = q; 00410 q += 2; 00411 running_status = 4; /* running */ 00412 free_ca_mode = 0; 00413 00414 /* write only one descriptor for the service name and provider */ 00415 *q++ = 0x48; 00416 desc_len_ptr = q; 00417 q++; 00418 *q++ = 0x01; /* digital television service */ 00419 putstr8(&q, service->provider_name); 00420 putstr8(&q, service->name); 00421 desc_len_ptr[0] = q - desc_len_ptr - 1; 00422 00423 /* fill descriptor length */ 00424 val = (running_status << 13) | (free_ca_mode << 12) | 00425 (q - desc_list_len_ptr - 2); 00426 desc_list_len_ptr[0] = val >> 8; 00427 desc_list_len_ptr[1] = val; 00428 } 00429 mpegts_write_section1(&ts->sdt, SDT_TID, ts->tsid, 0, 0, 0, 00430 data, q - data); 00431 } 00432 00433 static MpegTSService *mpegts_add_service(MpegTSWrite *ts, 00434 int sid, 00435 const char *provider_name, 00436 const char *name) 00437 { 00438 MpegTSService *service; 00439 00440 service = av_mallocz(sizeof(MpegTSService)); 00441 if (!service) 00442 return NULL; 00443 service->pmt.pid = ts->pmt_start_pid + ts->nb_services; 00444 service->sid = sid; 00445 service->provider_name = av_strdup(provider_name); 00446 service->name = av_strdup(name); 00447 service->pcr_pid = 0x1fff; 00448 dynarray_add(&ts->services, &ts->nb_services, service); 00449 return service; 00450 } 00451 00452 static int64_t get_pcr(const MpegTSWrite *ts, AVIOContext *pb) 00453 { 00454 return av_rescale(avio_tell(pb) + 11, 8 * PCR_TIME_BASE, ts->mux_rate) + 00455 ts->first_pcr; 00456 } 00457 00458 static void mpegts_prefix_m2ts_header(AVFormatContext *s) 00459 { 00460 MpegTSWrite *ts = s->priv_data; 00461 if (ts->m2ts_mode) { 00462 int64_t pcr = get_pcr(s->priv_data, s->pb); 00463 uint32_t tp_extra_header = pcr % 0x3fffffff; 00464 tp_extra_header = AV_RB32(&tp_extra_header); 00465 avio_write(s->pb, (unsigned char *) &tp_extra_header, 00466 sizeof(tp_extra_header)); 00467 } 00468 } 00469 00470 static void section_write_packet(MpegTSSection *s, const uint8_t *packet) 00471 { 00472 AVFormatContext *ctx = s->opaque; 00473 mpegts_prefix_m2ts_header(ctx); 00474 avio_write(ctx->pb, packet, TS_PACKET_SIZE); 00475 } 00476 00477 static int mpegts_write_header(AVFormatContext *s) 00478 { 00479 MpegTSWrite *ts = s->priv_data; 00480 MpegTSWriteStream *ts_st; 00481 MpegTSService *service; 00482 AVStream *st, *pcr_st = NULL; 00483 AVDictionaryEntry *title, *provider; 00484 int i, j; 00485 const char *service_name; 00486 const char *provider_name; 00487 int *pids; 00488 00489 // round up to a whole number of TS packets 00490 ts->pes_payload_size = (ts->pes_payload_size + 14 + 183) / 184 * 184 - 14; 00491 00492 ts->tsid = ts->transport_stream_id; 00493 ts->onid = ts->original_network_id; 00494 /* allocate a single DVB service */ 00495 title = av_dict_get(s->metadata, "service_name", NULL, 0); 00496 if (!title) 00497 title = av_dict_get(s->metadata, "title", NULL, 0); 00498 service_name = title ? title->value : DEFAULT_SERVICE_NAME; 00499 provider = av_dict_get(s->metadata, "service_provider", NULL, 0); 00500 provider_name = provider ? provider->value : DEFAULT_PROVIDER_NAME; 00501 service = mpegts_add_service(ts, ts->service_id, provider_name, service_name); 00502 service->pmt.write_packet = section_write_packet; 00503 service->pmt.opaque = s; 00504 service->pmt.cc = 15; 00505 00506 ts->pat.pid = PAT_PID; 00507 ts->pat.cc = 15; // Initialize at 15 so that it wraps and be equal to 0 for the first packet we write 00508 ts->pat.write_packet = section_write_packet; 00509 ts->pat.opaque = s; 00510 00511 ts->sdt.pid = SDT_PID; 00512 ts->sdt.cc = 15; 00513 ts->sdt.write_packet = section_write_packet; 00514 ts->sdt.opaque = s; 00515 00516 pids = av_malloc(s->nb_streams * sizeof(*pids)); 00517 if (!pids) 00518 return AVERROR(ENOMEM); 00519 00520 /* assign pids to each stream */ 00521 for(i = 0;i < s->nb_streams; i++) { 00522 st = s->streams[i]; 00523 avpriv_set_pts_info(st, 33, 1, 90000); 00524 ts_st = av_mallocz(sizeof(MpegTSWriteStream)); 00525 if (!ts_st) 00526 goto fail; 00527 st->priv_data = ts_st; 00528 ts_st->payload = av_mallocz(ts->pes_payload_size); 00529 if (!ts_st->payload) 00530 goto fail; 00531 ts_st->service = service; 00532 /* MPEG pid values < 16 are reserved. Applications which set st->id in 00533 * this range are assigned a calculated pid. */ 00534 if (st->id < 16) { 00535 ts_st->pid = ts->start_pid + i; 00536 } else if (st->id < 0x1FFF) { 00537 ts_st->pid = st->id; 00538 } else { 00539 av_log(s, AV_LOG_ERROR, "Invalid stream id %d, must be less than 8191\n", st->id); 00540 goto fail; 00541 } 00542 if (ts_st->pid == service->pmt.pid) { 00543 av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid); 00544 goto fail; 00545 } 00546 for (j = 0; j < i; j++) 00547 if (pids[j] == ts_st->pid) { 00548 av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid); 00549 goto fail; 00550 } 00551 pids[i] = ts_st->pid; 00552 ts_st->payload_pts = AV_NOPTS_VALUE; 00553 ts_st->payload_dts = AV_NOPTS_VALUE; 00554 ts_st->first_pts_check = 1; 00555 ts_st->cc = 15; 00556 /* update PCR pid by using the first video stream */ 00557 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && 00558 service->pcr_pid == 0x1fff) { 00559 service->pcr_pid = ts_st->pid; 00560 pcr_st = st; 00561 } 00562 if (st->codec->codec_id == CODEC_ID_AAC && 00563 st->codec->extradata_size > 0) { 00564 ts_st->adts = av_mallocz(sizeof(*ts_st->adts)); 00565 if (!ts_st->adts) 00566 goto fail; 00567 if (ff_adts_decode_extradata(s, ts_st->adts, st->codec->extradata, 00568 st->codec->extradata_size) < 0) 00569 goto fail; 00570 } 00571 } 00572 00573 av_free(pids); 00574 00575 /* if no video stream, use the first stream as PCR */ 00576 if (service->pcr_pid == 0x1fff && s->nb_streams > 0) { 00577 pcr_st = s->streams[0]; 00578 ts_st = pcr_st->priv_data; 00579 service->pcr_pid = ts_st->pid; 00580 } 00581 00582 #if FF_API_MUXRATE 00583 if (s->mux_rate) 00584 ts->mux_rate = s->mux_rate; 00585 #endif 00586 00587 if (ts->mux_rate > 1) { 00588 service->pcr_packet_period = (ts->mux_rate * PCR_RETRANS_TIME) / 00589 (TS_PACKET_SIZE * 8 * 1000); 00590 ts->sdt_packet_period = (ts->mux_rate * SDT_RETRANS_TIME) / 00591 (TS_PACKET_SIZE * 8 * 1000); 00592 ts->pat_packet_period = (ts->mux_rate * PAT_RETRANS_TIME) / 00593 (TS_PACKET_SIZE * 8 * 1000); 00594 00595 ts->first_pcr = av_rescale(s->max_delay, PCR_TIME_BASE, AV_TIME_BASE); 00596 } else { 00597 /* Arbitrary values, PAT/PMT could be written on key frames */ 00598 ts->sdt_packet_period = 200; 00599 ts->pat_packet_period = 40; 00600 if (pcr_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { 00601 if (!pcr_st->codec->frame_size) { 00602 av_log(s, AV_LOG_WARNING, "frame size not set\n"); 00603 service->pcr_packet_period = 00604 pcr_st->codec->sample_rate/(10*512); 00605 } else { 00606 service->pcr_packet_period = 00607 pcr_st->codec->sample_rate/(10*pcr_st->codec->frame_size); 00608 } 00609 } else { 00610 // max delta PCR 0.1s 00611 service->pcr_packet_period = 00612 pcr_st->codec->time_base.den/(10*pcr_st->codec->time_base.num); 00613 } 00614 } 00615 00616 // output a PCR as soon as possible 00617 service->pcr_packet_count = service->pcr_packet_period; 00618 ts->pat_packet_count = ts->pat_packet_period-1; 00619 ts->sdt_packet_count = ts->sdt_packet_period-1; 00620 00621 if (ts->mux_rate == 1) 00622 av_log(s, AV_LOG_INFO, "muxrate VBR, "); 00623 else 00624 av_log(s, AV_LOG_INFO, "muxrate %d, ", ts->mux_rate); 00625 av_log(s, AV_LOG_INFO, "pcr every %d pkts, " 00626 "sdt every %d, pat/pmt every %d pkts\n", 00627 service->pcr_packet_period, 00628 ts->sdt_packet_period, ts->pat_packet_period); 00629 00630 if (ts->m2ts_mode == -1) { 00631 if (av_match_ext(s->filename, "m2ts")) { 00632 ts->m2ts_mode = 1; 00633 } else { 00634 ts->m2ts_mode = 0; 00635 } 00636 } 00637 00638 avio_flush(s->pb); 00639 00640 return 0; 00641 00642 fail: 00643 av_free(pids); 00644 for(i = 0;i < s->nb_streams; i++) { 00645 MpegTSWriteStream *ts_st; 00646 st = s->streams[i]; 00647 ts_st = st->priv_data; 00648 if (ts_st) { 00649 av_freep(&ts_st->payload); 00650 av_freep(&ts_st->adts); 00651 } 00652 av_freep(&st->priv_data); 00653 } 00654 return AVERROR(EINVAL); 00655 } 00656 00657 /* send SDT, PAT and PMT tables regulary */ 00658 static void retransmit_si_info(AVFormatContext *s) 00659 { 00660 MpegTSWrite *ts = s->priv_data; 00661 int i; 00662 00663 if (++ts->sdt_packet_count == ts->sdt_packet_period) { 00664 ts->sdt_packet_count = 0; 00665 mpegts_write_sdt(s); 00666 } 00667 if (++ts->pat_packet_count == ts->pat_packet_period) { 00668 ts->pat_packet_count = 0; 00669 mpegts_write_pat(s); 00670 for(i = 0; i < ts->nb_services; i++) { 00671 mpegts_write_pmt(s, ts->services[i]); 00672 } 00673 } 00674 } 00675 00676 static int write_pcr_bits(uint8_t *buf, int64_t pcr) 00677 { 00678 int64_t pcr_low = pcr % 300, pcr_high = pcr / 300; 00679 00680 *buf++ = pcr_high >> 25; 00681 *buf++ = pcr_high >> 17; 00682 *buf++ = pcr_high >> 9; 00683 *buf++ = pcr_high >> 1; 00684 *buf++ = pcr_high << 7 | pcr_low >> 8 | 0x7e; 00685 *buf++ = pcr_low; 00686 00687 return 6; 00688 } 00689 00690 /* Write a single null transport stream packet */ 00691 static void mpegts_insert_null_packet(AVFormatContext *s) 00692 { 00693 uint8_t *q; 00694 uint8_t buf[TS_PACKET_SIZE]; 00695 00696 q = buf; 00697 *q++ = 0x47; 00698 *q++ = 0x00 | 0x1f; 00699 *q++ = 0xff; 00700 *q++ = 0x10; 00701 memset(q, 0x0FF, TS_PACKET_SIZE - (q - buf)); 00702 mpegts_prefix_m2ts_header(s); 00703 avio_write(s->pb, buf, TS_PACKET_SIZE); 00704 } 00705 00706 /* Write a single transport stream packet with a PCR and no payload */ 00707 static void mpegts_insert_pcr_only(AVFormatContext *s, AVStream *st) 00708 { 00709 MpegTSWrite *ts = s->priv_data; 00710 MpegTSWriteStream *ts_st = st->priv_data; 00711 uint8_t *q; 00712 uint8_t buf[TS_PACKET_SIZE]; 00713 00714 q = buf; 00715 *q++ = 0x47; 00716 *q++ = ts_st->pid >> 8; 00717 *q++ = ts_st->pid; 00718 *q++ = 0x20 | ts_st->cc; /* Adaptation only */ 00719 /* Continuity Count field does not increment (see 13818-1 section 2.4.3.3) */ 00720 *q++ = TS_PACKET_SIZE - 5; /* Adaptation Field Length */ 00721 *q++ = 0x10; /* Adaptation flags: PCR present */ 00722 00723 /* PCR coded into 6 bytes */ 00724 q += write_pcr_bits(q, get_pcr(ts, s->pb)); 00725 00726 /* stuffing bytes */ 00727 memset(q, 0xFF, TS_PACKET_SIZE - (q - buf)); 00728 mpegts_prefix_m2ts_header(s); 00729 avio_write(s->pb, buf, TS_PACKET_SIZE); 00730 } 00731 00732 static void write_pts(uint8_t *q, int fourbits, int64_t pts) 00733 { 00734 int val; 00735 00736 val = fourbits << 4 | (((pts >> 30) & 0x07) << 1) | 1; 00737 *q++ = val; 00738 val = (((pts >> 15) & 0x7fff) << 1) | 1; 00739 *q++ = val >> 8; 00740 *q++ = val; 00741 val = (((pts) & 0x7fff) << 1) | 1; 00742 *q++ = val >> 8; 00743 *q++ = val; 00744 } 00745 00746 /* Set an adaptation field flag in an MPEG-TS packet*/ 00747 static void set_af_flag(uint8_t *pkt, int flag) 00748 { 00749 // expect at least one flag to set 00750 assert(flag); 00751 00752 if ((pkt[3] & 0x20) == 0) { 00753 // no AF yet, set adaptation field flag 00754 pkt[3] |= 0x20; 00755 // 1 byte length, no flags 00756 pkt[4] = 1; 00757 pkt[5] = 0; 00758 } 00759 pkt[5] |= flag; 00760 } 00761 00762 /* Extend the adaptation field by size bytes */ 00763 static void extend_af(uint8_t *pkt, int size) 00764 { 00765 // expect already existing adaptation field 00766 assert(pkt[3] & 0x20); 00767 pkt[4] += size; 00768 } 00769 00770 /* Get a pointer to MPEG-TS payload (right after TS packet header) */ 00771 static uint8_t *get_ts_payload_start(uint8_t *pkt) 00772 { 00773 if (pkt[3] & 0x20) 00774 return pkt + 5 + pkt[4]; 00775 else 00776 return pkt + 4; 00777 } 00778 00779 /* Add a pes header to the front of payload, and segment into an integer number of 00780 * ts packets. The final ts packet is padded using an over-sized adaptation header 00781 * to exactly fill the last ts packet. 00782 * NOTE: 'payload' contains a complete PES payload. 00783 */ 00784 static void mpegts_write_pes(AVFormatContext *s, AVStream *st, 00785 const uint8_t *payload, int payload_size, 00786 int64_t pts, int64_t dts, int key) 00787 { 00788 MpegTSWriteStream *ts_st = st->priv_data; 00789 MpegTSWrite *ts = s->priv_data; 00790 uint8_t buf[TS_PACKET_SIZE]; 00791 uint8_t *q; 00792 int val, is_start, len, header_len, write_pcr, private_code, flags; 00793 int afc_len, stuffing_len; 00794 int64_t pcr = -1; /* avoid warning */ 00795 int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE); 00796 00797 is_start = 1; 00798 while (payload_size > 0) { 00799 retransmit_si_info(s); 00800 00801 write_pcr = 0; 00802 if (ts_st->pid == ts_st->service->pcr_pid) { 00803 if (ts->mux_rate > 1 || is_start) // VBR pcr period is based on frames 00804 ts_st->service->pcr_packet_count++; 00805 if (ts_st->service->pcr_packet_count >= 00806 ts_st->service->pcr_packet_period) { 00807 ts_st->service->pcr_packet_count = 0; 00808 write_pcr = 1; 00809 } 00810 } 00811 00812 if (ts->mux_rate > 1 && dts != AV_NOPTS_VALUE && 00813 (dts - get_pcr(ts, s->pb)/300) > delay) { 00814 /* pcr insert gets priority over null packet insert */ 00815 if (write_pcr) 00816 mpegts_insert_pcr_only(s, st); 00817 else 00818 mpegts_insert_null_packet(s); 00819 continue; /* recalculate write_pcr and possibly retransmit si_info */ 00820 } 00821 00822 /* prepare packet header */ 00823 q = buf; 00824 *q++ = 0x47; 00825 val = (ts_st->pid >> 8); 00826 if (is_start) 00827 val |= 0x40; 00828 *q++ = val; 00829 *q++ = ts_st->pid; 00830 ts_st->cc = (ts_st->cc + 1) & 0xf; 00831 *q++ = 0x10 | ts_st->cc; // payload indicator + CC 00832 if (key && is_start && pts != AV_NOPTS_VALUE) { 00833 // set Random Access for key frames 00834 if (ts_st->pid == ts_st->service->pcr_pid) 00835 write_pcr = 1; 00836 set_af_flag(buf, 0x40); 00837 q = get_ts_payload_start(buf); 00838 } 00839 if (write_pcr) { 00840 set_af_flag(buf, 0x10); 00841 q = get_ts_payload_start(buf); 00842 // add 11, pcr references the last byte of program clock reference base 00843 if (ts->mux_rate > 1) 00844 pcr = get_pcr(ts, s->pb); 00845 else 00846 pcr = (dts - delay)*300; 00847 if (dts != AV_NOPTS_VALUE && dts < pcr / 300) 00848 av_log(s, AV_LOG_WARNING, "dts < pcr, TS is invalid\n"); 00849 extend_af(buf, write_pcr_bits(q, pcr)); 00850 q = get_ts_payload_start(buf); 00851 } 00852 if (is_start) { 00853 int pes_extension = 0; 00854 /* write PES header */ 00855 *q++ = 0x00; 00856 *q++ = 0x00; 00857 *q++ = 0x01; 00858 private_code = 0; 00859 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { 00860 if (st->codec->codec_id == CODEC_ID_DIRAC) { 00861 *q++ = 0xfd; 00862 } else 00863 *q++ = 0xe0; 00864 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && 00865 (st->codec->codec_id == CODEC_ID_MP2 || 00866 st->codec->codec_id == CODEC_ID_MP3 || 00867 st->codec->codec_id == CODEC_ID_AAC)) { 00868 *q++ = 0xc0; 00869 } else { 00870 *q++ = 0xbd; 00871 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) { 00872 private_code = 0x20; 00873 } 00874 } 00875 header_len = 0; 00876 flags = 0; 00877 if (pts != AV_NOPTS_VALUE) { 00878 header_len += 5; 00879 flags |= 0x80; 00880 } 00881 if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) { 00882 header_len += 5; 00883 flags |= 0x40; 00884 } 00885 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && 00886 st->codec->codec_id == CODEC_ID_DIRAC) { 00887 /* set PES_extension_flag */ 00888 pes_extension = 1; 00889 flags |= 0x01; 00890 00891 /* 00892 * One byte for PES2 extension flag + 00893 * one byte for extension length + 00894 * one byte for extension id 00895 */ 00896 header_len += 3; 00897 } 00898 len = payload_size + header_len + 3; 00899 if (private_code != 0) 00900 len++; 00901 if (len > 0xffff) 00902 len = 0; 00903 *q++ = len >> 8; 00904 *q++ = len; 00905 val = 0x80; 00906 /* data alignment indicator is required for subtitle data */ 00907 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) 00908 val |= 0x04; 00909 *q++ = val; 00910 *q++ = flags; 00911 *q++ = header_len; 00912 if (pts != AV_NOPTS_VALUE) { 00913 write_pts(q, flags >> 6, pts); 00914 q += 5; 00915 } 00916 if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) { 00917 write_pts(q, 1, dts); 00918 q += 5; 00919 } 00920 if (pes_extension && st->codec->codec_id == CODEC_ID_DIRAC) { 00921 flags = 0x01; /* set PES_extension_flag_2 */ 00922 *q++ = flags; 00923 *q++ = 0x80 | 0x01; /* marker bit + extension length */ 00924 /* 00925 * Set the stream id extension flag bit to 0 and 00926 * write the extended stream id 00927 */ 00928 *q++ = 0x00 | 0x60; 00929 } 00930 if (private_code != 0) 00931 *q++ = private_code; 00932 is_start = 0; 00933 } 00934 /* header size */ 00935 header_len = q - buf; 00936 /* data len */ 00937 len = TS_PACKET_SIZE - header_len; 00938 if (len > payload_size) 00939 len = payload_size; 00940 stuffing_len = TS_PACKET_SIZE - header_len - len; 00941 if (stuffing_len > 0) { 00942 /* add stuffing with AFC */ 00943 if (buf[3] & 0x20) { 00944 /* stuffing already present: increase its size */ 00945 afc_len = buf[4] + 1; 00946 memmove(buf + 4 + afc_len + stuffing_len, 00947 buf + 4 + afc_len, 00948 header_len - (4 + afc_len)); 00949 buf[4] += stuffing_len; 00950 memset(buf + 4 + afc_len, 0xff, stuffing_len); 00951 } else { 00952 /* add stuffing */ 00953 memmove(buf + 4 + stuffing_len, buf + 4, header_len - 4); 00954 buf[3] |= 0x20; 00955 buf[4] = stuffing_len - 1; 00956 if (stuffing_len >= 2) { 00957 buf[5] = 0x00; 00958 memset(buf + 6, 0xff, stuffing_len - 2); 00959 } 00960 } 00961 } 00962 memcpy(buf + TS_PACKET_SIZE - len, payload, len); 00963 payload += len; 00964 payload_size -= len; 00965 mpegts_prefix_m2ts_header(s); 00966 avio_write(s->pb, buf, TS_PACKET_SIZE); 00967 } 00968 avio_flush(s->pb); 00969 } 00970 00971 static int mpegts_write_packet(AVFormatContext *s, AVPacket *pkt) 00972 { 00973 AVStream *st = s->streams[pkt->stream_index]; 00974 int size = pkt->size; 00975 uint8_t *buf= pkt->data; 00976 uint8_t *data= NULL; 00977 MpegTSWrite *ts = s->priv_data; 00978 MpegTSWriteStream *ts_st = st->priv_data; 00979 const uint64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE)*2; 00980 int64_t dts = AV_NOPTS_VALUE, pts = AV_NOPTS_VALUE; 00981 00982 if (pkt->pts != AV_NOPTS_VALUE) 00983 pts = pkt->pts + delay; 00984 if (pkt->dts != AV_NOPTS_VALUE) 00985 dts = pkt->dts + delay; 00986 00987 if (ts_st->first_pts_check && pts == AV_NOPTS_VALUE) { 00988 av_log(s, AV_LOG_ERROR, "first pts value must set\n"); 00989 return AVERROR_INVALIDDATA; 00990 } 00991 ts_st->first_pts_check = 0; 00992 00993 if (st->codec->codec_id == CODEC_ID_H264) { 00994 const uint8_t *p = buf, *buf_end = p+size; 00995 uint32_t state = -1; 00996 00997 if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001) { 00998 av_log(s, AV_LOG_ERROR, "H.264 bitstream malformed, " 00999 "no startcode found, use the h264_mp4toannexb bitstream filter\n"); 01000 return AVERROR_INVALIDDATA; 01001 } 01002 01003 do { 01004 p = avpriv_mpv_find_start_code(p, buf_end, &state); 01005 //av_log(s, AV_LOG_INFO, "nal %d\n", state & 0x1f); 01006 } while (p < buf_end && (state & 0x1f) != 9 && 01007 (state & 0x1f) != 5 && (state & 0x1f) != 1); 01008 01009 if ((state & 0x1f) != 9) { // AUD NAL 01010 data = av_malloc(pkt->size+6); 01011 if (!data) 01012 return AVERROR(ENOMEM); 01013 memcpy(data+6, pkt->data, pkt->size); 01014 AV_WB32(data, 0x00000001); 01015 data[4] = 0x09; 01016 data[5] = 0xf0; // any slice type (0xe) + rbsp stop one bit 01017 buf = data; 01018 size = pkt->size+6; 01019 } 01020 } else if (st->codec->codec_id == CODEC_ID_AAC) { 01021 if (pkt->size < 2) 01022 return AVERROR_INVALIDDATA; 01023 if ((AV_RB16(pkt->data) & 0xfff0) != 0xfff0) { 01024 ADTSContext *adts = ts_st->adts; 01025 int new_size, err; 01026 if (!adts) { 01027 av_log(s, AV_LOG_ERROR, "AAC bitstream not in ADTS format " 01028 "and extradata missing\n"); 01029 return AVERROR_INVALIDDATA; 01030 } 01031 new_size = ADTS_HEADER_SIZE+adts->pce_size+pkt->size; 01032 if ((unsigned)new_size >= INT_MAX) 01033 return AVERROR_INVALIDDATA; 01034 data = av_malloc(new_size); 01035 if (!data) 01036 return AVERROR(ENOMEM); 01037 err = ff_adts_write_frame_header(adts, data, pkt->size, 01038 adts->pce_size); 01039 if (err < 0) { 01040 av_free(data); 01041 return err; 01042 } 01043 if (adts->pce_size) { 01044 memcpy(data+ADTS_HEADER_SIZE, adts->pce_data, adts->pce_size); 01045 adts->pce_size = 0; 01046 } 01047 memcpy(data+ADTS_HEADER_SIZE+adts->pce_size, pkt->data, pkt->size); 01048 buf = data; 01049 size = new_size; 01050 } 01051 } 01052 01053 if (ts_st->payload_size && ts_st->payload_size + size > ts->pes_payload_size) { 01054 mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size, 01055 ts_st->payload_pts, ts_st->payload_dts, 01056 ts_st->payload_flags & AV_PKT_FLAG_KEY); 01057 ts_st->payload_size = 0; 01058 } 01059 01060 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO || size > ts->pes_payload_size) { 01061 av_assert0(!ts_st->payload_size); 01062 // for video and subtitle, write a single pes packet 01063 mpegts_write_pes(s, st, buf, size, pts, dts, pkt->flags & AV_PKT_FLAG_KEY); 01064 av_free(data); 01065 return 0; 01066 } 01067 01068 if (!ts_st->payload_size) { 01069 ts_st->payload_pts = pts; 01070 ts_st->payload_dts = dts; 01071 ts_st->payload_flags = pkt->flags; 01072 } 01073 01074 memcpy(ts_st->payload + ts_st->payload_size, buf, size); 01075 ts_st->payload_size += size; 01076 01077 av_free(data); 01078 01079 return 0; 01080 } 01081 01082 static int mpegts_write_end(AVFormatContext *s) 01083 { 01084 MpegTSWrite *ts = s->priv_data; 01085 MpegTSWriteStream *ts_st; 01086 MpegTSService *service; 01087 AVStream *st; 01088 int i; 01089 01090 /* flush current packets */ 01091 for(i = 0; i < s->nb_streams; i++) { 01092 st = s->streams[i]; 01093 ts_st = st->priv_data; 01094 if (ts_st->payload_size > 0) { 01095 mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size, 01096 ts_st->payload_pts, ts_st->payload_dts, 01097 ts_st->payload_flags & AV_PKT_FLAG_KEY); 01098 } 01099 av_freep(&ts_st->payload); 01100 av_freep(&ts_st->adts); 01101 } 01102 avio_flush(s->pb); 01103 01104 for(i = 0; i < ts->nb_services; i++) { 01105 service = ts->services[i]; 01106 av_freep(&service->provider_name); 01107 av_freep(&service->name); 01108 av_free(service); 01109 } 01110 av_free(ts->services); 01111 01112 return 0; 01113 } 01114 01115 AVOutputFormat ff_mpegts_muxer = { 01116 .name = "mpegts", 01117 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"), 01118 .mime_type = "video/x-mpegts", 01119 .extensions = "ts,m2t,m2ts,mts", 01120 .priv_data_size = sizeof(MpegTSWrite), 01121 .audio_codec = CODEC_ID_MP2, 01122 .video_codec = CODEC_ID_MPEG2VIDEO, 01123 .write_header = mpegts_write_header, 01124 .write_packet = mpegts_write_packet, 01125 .write_trailer = mpegts_write_end, 01126 .priv_class = &mpegts_muxer_class, 01127 };