00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
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
00037
00038
00039
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;
00050 int sid;
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;
00061 MpegTSSection sdt;
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
00082 int reemit_pat_pmt;
00083 } MpegTSWrite;
00084
00085
00086 #define DEFAULT_PES_HEADER_FREQ 16
00087 #define DEFAULT_PES_PAYLOAD_SIZE ((DEFAULT_PES_HEADER_FREQ - 1) * 184 + 170)
00088
00089 static const AVOption options[] = {
00090 { "mpegts_transport_stream_id", "Set transport_stream_id field.",
00091 offsetof(MpegTSWrite, transport_stream_id), AV_OPT_TYPE_INT, {.dbl = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
00092 { "mpegts_original_network_id", "Set original_network_id field.",
00093 offsetof(MpegTSWrite, original_network_id), AV_OPT_TYPE_INT, {.dbl = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
00094 { "mpegts_service_id", "Set service_id field.",
00095 offsetof(MpegTSWrite, service_id), AV_OPT_TYPE_INT, {.dbl = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
00096 { "mpegts_pmt_start_pid", "Set the first pid of the PMT.",
00097 offsetof(MpegTSWrite, pmt_start_pid), AV_OPT_TYPE_INT, {.dbl = 0x1000 }, 0x0010, 0x1f00, AV_OPT_FLAG_ENCODING_PARAM},
00098 { "mpegts_start_pid", "Set the first pid.",
00099 offsetof(MpegTSWrite, start_pid), AV_OPT_TYPE_INT, {.dbl = 0x0100 }, 0x0100, 0x0f00, AV_OPT_FLAG_ENCODING_PARAM},
00100 {"mpegts_m2ts_mode", "Enable m2ts mode.",
00101 offsetof(MpegTSWrite, m2ts_mode), AV_OPT_TYPE_INT, {.dbl = -1 },
00102 -1,1, AV_OPT_FLAG_ENCODING_PARAM},
00103 { "muxrate", NULL, offsetof(MpegTSWrite, mux_rate), AV_OPT_TYPE_INT, {1}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
00104 { "pes_payload_size", "Minimum PES packet payload in bytes",
00105 offsetof(MpegTSWrite, pes_payload_size), AV_OPT_TYPE_INT, {DEFAULT_PES_PAYLOAD_SIZE}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
00106 { "resend_headers", "Reemit PAT/PMT before writing the next packet",
00107 offsetof(MpegTSWrite, reemit_pat_pmt), AV_OPT_TYPE_INT, {0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
00108 { NULL },
00109 };
00110
00111 static const AVClass mpegts_muxer_class = {
00112 .class_name = "MPEGTS muxer",
00113 .item_name = av_default_item_name,
00114 .option = options,
00115 .version = LIBAVUTIL_VERSION_INT,
00116 };
00117
00118
00119 static void mpegts_write_section(MpegTSSection *s, uint8_t *buf, int len)
00120 {
00121 unsigned int crc;
00122 unsigned char packet[TS_PACKET_SIZE];
00123 const unsigned char *buf_ptr;
00124 unsigned char *q;
00125 int first, b, len1, left;
00126
00127 crc = av_bswap32(av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, buf, len - 4));
00128 buf[len - 4] = (crc >> 24) & 0xff;
00129 buf[len - 3] = (crc >> 16) & 0xff;
00130 buf[len - 2] = (crc >> 8) & 0xff;
00131 buf[len - 1] = (crc) & 0xff;
00132
00133
00134 buf_ptr = buf;
00135 while (len > 0) {
00136 first = (buf == buf_ptr);
00137 q = packet;
00138 *q++ = 0x47;
00139 b = (s->pid >> 8);
00140 if (first)
00141 b |= 0x40;
00142 *q++ = b;
00143 *q++ = s->pid;
00144 s->cc = (s->cc + 1) & 0xf;
00145 *q++ = 0x10 | s->cc;
00146 if (first)
00147 *q++ = 0;
00148 len1 = TS_PACKET_SIZE - (q - packet);
00149 if (len1 > len)
00150 len1 = len;
00151 memcpy(q, buf_ptr, len1);
00152 q += len1;
00153
00154 left = TS_PACKET_SIZE - (q - packet);
00155 if (left > 0)
00156 memset(q, 0xff, left);
00157
00158 s->write_packet(s, packet);
00159
00160 buf_ptr += len1;
00161 len -= len1;
00162 }
00163 }
00164
00165 static inline void put16(uint8_t **q_ptr, int val)
00166 {
00167 uint8_t *q;
00168 q = *q_ptr;
00169 *q++ = val >> 8;
00170 *q++ = val;
00171 *q_ptr = q;
00172 }
00173
00174 static int mpegts_write_section1(MpegTSSection *s, int tid, int id,
00175 int version, int sec_num, int last_sec_num,
00176 uint8_t *buf, int len)
00177 {
00178 uint8_t section[1024], *q;
00179 unsigned int tot_len;
00180
00181 unsigned int flags = tid == SDT_TID ? 0xf000 : 0xb000;
00182
00183 tot_len = 3 + 5 + len + 4;
00184
00185 if (tot_len > 1024)
00186 return AVERROR_INVALIDDATA;
00187
00188 q = section;
00189 *q++ = tid;
00190 put16(&q, flags | (len + 5 + 4));
00191 put16(&q, id);
00192 *q++ = 0xc1 | (version << 1);
00193 *q++ = sec_num;
00194 *q++ = last_sec_num;
00195 memcpy(q, buf, len);
00196
00197 mpegts_write_section(s, section, tot_len);
00198 return 0;
00199 }
00200
00201
00202
00203
00204 #define DEFAULT_PROVIDER_NAME "FFmpeg"
00205 #define DEFAULT_SERVICE_NAME "Service01"
00206
00207
00208 #define SDT_RETRANS_TIME 500
00209 #define PAT_RETRANS_TIME 100
00210 #define PCR_RETRANS_TIME 20
00211
00212 typedef struct MpegTSWriteStream {
00213 struct MpegTSService *service;
00214 int pid;
00215 int cc;
00216 int payload_size;
00217 int first_pts_check;
00218 int prev_payload_key;
00219 int64_t payload_pts;
00220 int64_t payload_dts;
00221 int payload_flags;
00222 uint8_t *payload;
00223 ADTSContext *adts;
00224 } MpegTSWriteStream;
00225
00226 static void mpegts_write_pat(AVFormatContext *s)
00227 {
00228 MpegTSWrite *ts = s->priv_data;
00229 MpegTSService *service;
00230 uint8_t data[1012], *q;
00231 int i;
00232
00233 q = data;
00234 for(i = 0; i < ts->nb_services; i++) {
00235 service = ts->services[i];
00236 put16(&q, service->sid);
00237 put16(&q, 0xe000 | service->pmt.pid);
00238 }
00239 mpegts_write_section1(&ts->pat, PAT_TID, ts->tsid, 0, 0, 0,
00240 data, q - data);
00241 }
00242
00243 static void mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
00244 {
00245
00246 uint8_t data[1012], *q, *desc_length_ptr, *program_info_length_ptr;
00247 int val, stream_type, i;
00248
00249 q = data;
00250 put16(&q, 0xe000 | service->pcr_pid);
00251
00252 program_info_length_ptr = q;
00253 q += 2;
00254
00255
00256
00257 val = 0xf000 | (q - program_info_length_ptr - 2);
00258 program_info_length_ptr[0] = val >> 8;
00259 program_info_length_ptr[1] = val;
00260
00261 for(i = 0; i < s->nb_streams; i++) {
00262 AVStream *st = s->streams[i];
00263 MpegTSWriteStream *ts_st = st->priv_data;
00264 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL,0);
00265 switch(st->codec->codec_id) {
00266 case CODEC_ID_MPEG1VIDEO:
00267 case CODEC_ID_MPEG2VIDEO:
00268 stream_type = STREAM_TYPE_VIDEO_MPEG2;
00269 break;
00270 case CODEC_ID_MPEG4:
00271 stream_type = STREAM_TYPE_VIDEO_MPEG4;
00272 break;
00273 case CODEC_ID_H264:
00274 stream_type = STREAM_TYPE_VIDEO_H264;
00275 break;
00276 case CODEC_ID_DIRAC:
00277 stream_type = STREAM_TYPE_VIDEO_DIRAC;
00278 break;
00279 case CODEC_ID_MP2:
00280 case CODEC_ID_MP3:
00281 stream_type = STREAM_TYPE_AUDIO_MPEG1;
00282 break;
00283 case CODEC_ID_AAC:
00284 stream_type = STREAM_TYPE_AUDIO_AAC;
00285 break;
00286 case CODEC_ID_AAC_LATM:
00287 stream_type = STREAM_TYPE_AUDIO_AAC_LATM;
00288 break;
00289 case CODEC_ID_AC3:
00290 stream_type = STREAM_TYPE_AUDIO_AC3;
00291 break;
00292 default:
00293 stream_type = STREAM_TYPE_PRIVATE_DATA;
00294 break;
00295 }
00296 *q++ = stream_type;
00297 put16(&q, 0xe000 | ts_st->pid);
00298 desc_length_ptr = q;
00299 q += 2;
00300
00301
00302 switch(st->codec->codec_type) {
00303 case AVMEDIA_TYPE_AUDIO:
00304 if(st->codec->codec_id==CODEC_ID_EAC3){
00305 *q++=0x7a;
00306 *q++=1;
00307 *q++=0;
00308 }
00309 if(st->codec->codec_id==CODEC_ID_S302M){
00310 *q++ = 0x05;
00311 *q++ = 4;
00312 *q++ = 'B';
00313 *q++ = 'S';
00314 *q++ = 'S';
00315 *q++ = 'D';
00316 }
00317
00318 if (lang) {
00319 char *p;
00320 char *next = lang->value;
00321 uint8_t *len_ptr;
00322
00323 *q++ = 0x0a;
00324 len_ptr = q++;
00325 *len_ptr = 0;
00326
00327 for (p = lang->value; next && *len_ptr < 255 / 4 * 4; p = next + 1) {
00328 next = strchr(p, ',');
00329 if (strlen(p) != 3 && (!next || next != p + 3))
00330 continue;
00331
00332 *q++ = *p++;
00333 *q++ = *p++;
00334 *q++ = *p++;
00335
00336 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
00337 *q++ = 0x01;
00338 else if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
00339 *q++ = 0x02;
00340 else if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
00341 *q++ = 0x03;
00342 else
00343 *q++ = 0;
00344
00345 *len_ptr += 4;
00346 }
00347
00348 if (*len_ptr == 0)
00349 q -= 2;
00350 }
00351 break;
00352 case AVMEDIA_TYPE_SUBTITLE:
00353 {
00354 const char *language;
00355 language = lang && strlen(lang->value)==3 ? lang->value : "eng";
00356 *q++ = 0x59;
00357 *q++ = 8;
00358 *q++ = language[0];
00359 *q++ = language[1];
00360 *q++ = language[2];
00361 *q++ = 0x10;
00362 if(st->codec->extradata_size == 4) {
00363 memcpy(q, st->codec->extradata, 4);
00364 q += 4;
00365 } else {
00366 put16(&q, 1);
00367 put16(&q, 1);
00368 }
00369 }
00370 break;
00371 case AVMEDIA_TYPE_VIDEO:
00372 if (stream_type == STREAM_TYPE_VIDEO_DIRAC) {
00373 *q++ = 0x05;
00374 *q++ = 4;
00375 *q++ = 'd';
00376 *q++ = 'r';
00377 *q++ = 'a';
00378 *q++ = 'c';
00379 }
00380 break;
00381 }
00382
00383 val = 0xf000 | (q - desc_length_ptr - 2);
00384 desc_length_ptr[0] = val >> 8;
00385 desc_length_ptr[1] = val;
00386 }
00387 mpegts_write_section1(&service->pmt, PMT_TID, service->sid, 0, 0, 0,
00388 data, q - data);
00389 }
00390
00391
00392 static void putstr8(uint8_t **q_ptr, const char *str)
00393 {
00394 uint8_t *q;
00395 int len;
00396
00397 q = *q_ptr;
00398 if (!str)
00399 len = 0;
00400 else
00401 len = strlen(str);
00402 *q++ = len;
00403 memcpy(q, str, len);
00404 q += len;
00405 *q_ptr = q;
00406 }
00407
00408 static void mpegts_write_sdt(AVFormatContext *s)
00409 {
00410 MpegTSWrite *ts = s->priv_data;
00411 MpegTSService *service;
00412 uint8_t data[1012], *q, *desc_list_len_ptr, *desc_len_ptr;
00413 int i, running_status, free_ca_mode, val;
00414
00415 q = data;
00416 put16(&q, ts->onid);
00417 *q++ = 0xff;
00418 for(i = 0; i < ts->nb_services; i++) {
00419 service = ts->services[i];
00420 put16(&q, service->sid);
00421 *q++ = 0xfc | 0x00;
00422 desc_list_len_ptr = q;
00423 q += 2;
00424 running_status = 4;
00425 free_ca_mode = 0;
00426
00427
00428 *q++ = 0x48;
00429 desc_len_ptr = q;
00430 q++;
00431 *q++ = 0x01;
00432 putstr8(&q, service->provider_name);
00433 putstr8(&q, service->name);
00434 desc_len_ptr[0] = q - desc_len_ptr - 1;
00435
00436
00437 val = (running_status << 13) | (free_ca_mode << 12) |
00438 (q - desc_list_len_ptr - 2);
00439 desc_list_len_ptr[0] = val >> 8;
00440 desc_list_len_ptr[1] = val;
00441 }
00442 mpegts_write_section1(&ts->sdt, SDT_TID, ts->tsid, 0, 0, 0,
00443 data, q - data);
00444 }
00445
00446 static MpegTSService *mpegts_add_service(MpegTSWrite *ts,
00447 int sid,
00448 const char *provider_name,
00449 const char *name)
00450 {
00451 MpegTSService *service;
00452
00453 service = av_mallocz(sizeof(MpegTSService));
00454 if (!service)
00455 return NULL;
00456 service->pmt.pid = ts->pmt_start_pid + ts->nb_services;
00457 service->sid = sid;
00458 service->provider_name = av_strdup(provider_name);
00459 service->name = av_strdup(name);
00460 service->pcr_pid = 0x1fff;
00461 dynarray_add(&ts->services, &ts->nb_services, service);
00462 return service;
00463 }
00464
00465 static int64_t get_pcr(const MpegTSWrite *ts, AVIOContext *pb)
00466 {
00467 return av_rescale(avio_tell(pb) + 11, 8 * PCR_TIME_BASE, ts->mux_rate) +
00468 ts->first_pcr;
00469 }
00470
00471 static void mpegts_prefix_m2ts_header(AVFormatContext *s)
00472 {
00473 MpegTSWrite *ts = s->priv_data;
00474 if (ts->m2ts_mode) {
00475 int64_t pcr = get_pcr(s->priv_data, s->pb);
00476 uint32_t tp_extra_header = pcr % 0x3fffffff;
00477 tp_extra_header = AV_RB32(&tp_extra_header);
00478 avio_write(s->pb, (unsigned char *) &tp_extra_header,
00479 sizeof(tp_extra_header));
00480 }
00481 }
00482
00483 static void section_write_packet(MpegTSSection *s, const uint8_t *packet)
00484 {
00485 AVFormatContext *ctx = s->opaque;
00486 mpegts_prefix_m2ts_header(ctx);
00487 avio_write(ctx->pb, packet, TS_PACKET_SIZE);
00488 }
00489
00490 static int mpegts_write_header(AVFormatContext *s)
00491 {
00492 MpegTSWrite *ts = s->priv_data;
00493 MpegTSWriteStream *ts_st;
00494 MpegTSService *service;
00495 AVStream *st, *pcr_st = NULL;
00496 AVDictionaryEntry *title, *provider;
00497 int i, j;
00498 const char *service_name;
00499 const char *provider_name;
00500 int *pids;
00501
00502 if (s->max_delay < 0)
00503 s->max_delay = 0;
00504
00505
00506 ts->pes_payload_size = (ts->pes_payload_size + 14 + 183) / 184 * 184 - 14;
00507
00508 ts->tsid = ts->transport_stream_id;
00509 ts->onid = ts->original_network_id;
00510
00511 title = av_dict_get(s->metadata, "service_name", NULL, 0);
00512 if (!title)
00513 title = av_dict_get(s->metadata, "title", NULL, 0);
00514 service_name = title ? title->value : DEFAULT_SERVICE_NAME;
00515 provider = av_dict_get(s->metadata, "service_provider", NULL, 0);
00516 provider_name = provider ? provider->value : DEFAULT_PROVIDER_NAME;
00517 service = mpegts_add_service(ts, ts->service_id, provider_name, service_name);
00518 service->pmt.write_packet = section_write_packet;
00519 service->pmt.opaque = s;
00520 service->pmt.cc = 15;
00521
00522 ts->pat.pid = PAT_PID;
00523 ts->pat.cc = 15;
00524 ts->pat.write_packet = section_write_packet;
00525 ts->pat.opaque = s;
00526
00527 ts->sdt.pid = SDT_PID;
00528 ts->sdt.cc = 15;
00529 ts->sdt.write_packet = section_write_packet;
00530 ts->sdt.opaque = s;
00531
00532 pids = av_malloc(s->nb_streams * sizeof(*pids));
00533 if (!pids)
00534 return AVERROR(ENOMEM);
00535
00536
00537 for(i = 0;i < s->nb_streams; i++) {
00538 st = s->streams[i];
00539 avpriv_set_pts_info(st, 33, 1, 90000);
00540 ts_st = av_mallocz(sizeof(MpegTSWriteStream));
00541 if (!ts_st)
00542 goto fail;
00543 st->priv_data = ts_st;
00544 ts_st->payload = av_mallocz(ts->pes_payload_size);
00545 if (!ts_st->payload)
00546 goto fail;
00547 ts_st->service = service;
00548
00549
00550 if (st->id < 16) {
00551 ts_st->pid = ts->start_pid + i;
00552 } else if (st->id < 0x1FFF) {
00553 ts_st->pid = st->id;
00554 } else {
00555 av_log(s, AV_LOG_ERROR, "Invalid stream id %d, must be less than 8191\n", st->id);
00556 goto fail;
00557 }
00558 if (ts_st->pid == service->pmt.pid) {
00559 av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid);
00560 goto fail;
00561 }
00562 for (j = 0; j < i; j++)
00563 if (pids[j] == ts_st->pid) {
00564 av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid);
00565 goto fail;
00566 }
00567 pids[i] = ts_st->pid;
00568 ts_st->payload_pts = AV_NOPTS_VALUE;
00569 ts_st->payload_dts = AV_NOPTS_VALUE;
00570 ts_st->first_pts_check = 1;
00571 ts_st->cc = 15;
00572
00573 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
00574 service->pcr_pid == 0x1fff) {
00575 service->pcr_pid = ts_st->pid;
00576 pcr_st = st;
00577 }
00578 if (st->codec->codec_id == CODEC_ID_AAC &&
00579 st->codec->extradata_size > 0) {
00580 ts_st->adts = av_mallocz(sizeof(*ts_st->adts));
00581 if (!ts_st->adts)
00582 goto fail;
00583 if (ff_adts_decode_extradata(s, ts_st->adts, st->codec->extradata,
00584 st->codec->extradata_size) < 0)
00585 goto fail;
00586 }
00587 }
00588
00589 av_free(pids);
00590
00591
00592 if (service->pcr_pid == 0x1fff && s->nb_streams > 0) {
00593 pcr_st = s->streams[0];
00594 ts_st = pcr_st->priv_data;
00595 service->pcr_pid = ts_st->pid;
00596 }
00597
00598 if (ts->mux_rate > 1) {
00599 service->pcr_packet_period = (ts->mux_rate * PCR_RETRANS_TIME) /
00600 (TS_PACKET_SIZE * 8 * 1000);
00601 ts->sdt_packet_period = (ts->mux_rate * SDT_RETRANS_TIME) /
00602 (TS_PACKET_SIZE * 8 * 1000);
00603 ts->pat_packet_period = (ts->mux_rate * PAT_RETRANS_TIME) /
00604 (TS_PACKET_SIZE * 8 * 1000);
00605
00606 ts->first_pcr = av_rescale(s->max_delay, PCR_TIME_BASE, AV_TIME_BASE);
00607 } else {
00608
00609 ts->sdt_packet_period = 200;
00610 ts->pat_packet_period = 40;
00611 if (pcr_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
00612 if (!pcr_st->codec->frame_size) {
00613 av_log(s, AV_LOG_WARNING, "frame size not set\n");
00614 service->pcr_packet_period =
00615 pcr_st->codec->sample_rate/(10*512);
00616 } else {
00617 service->pcr_packet_period =
00618 pcr_st->codec->sample_rate/(10*pcr_st->codec->frame_size);
00619 }
00620 } else {
00621
00622 service->pcr_packet_period =
00623 pcr_st->codec->time_base.den/(10*pcr_st->codec->time_base.num);
00624 }
00625 }
00626
00627
00628 service->pcr_packet_count = service->pcr_packet_period;
00629 ts->pat_packet_count = ts->pat_packet_period-1;
00630 ts->sdt_packet_count = ts->sdt_packet_period-1;
00631
00632 if (ts->mux_rate == 1)
00633 av_log(s, AV_LOG_INFO, "muxrate VBR, ");
00634 else
00635 av_log(s, AV_LOG_INFO, "muxrate %d, ", ts->mux_rate);
00636 av_log(s, AV_LOG_INFO, "pcr every %d pkts, "
00637 "sdt every %d, pat/pmt every %d pkts\n",
00638 service->pcr_packet_period,
00639 ts->sdt_packet_period, ts->pat_packet_period);
00640
00641 if (ts->m2ts_mode == -1) {
00642 if (av_match_ext(s->filename, "m2ts")) {
00643 ts->m2ts_mode = 1;
00644 } else {
00645 ts->m2ts_mode = 0;
00646 }
00647 }
00648
00649 avio_flush(s->pb);
00650
00651 return 0;
00652
00653 fail:
00654 av_free(pids);
00655 for(i = 0;i < s->nb_streams; i++) {
00656 MpegTSWriteStream *ts_st;
00657 st = s->streams[i];
00658 ts_st = st->priv_data;
00659 if (ts_st) {
00660 av_freep(&ts_st->payload);
00661 av_freep(&ts_st->adts);
00662 }
00663 av_freep(&st->priv_data);
00664 }
00665 return AVERROR(EINVAL);
00666 }
00667
00668
00669 static void retransmit_si_info(AVFormatContext *s, int force_pat)
00670 {
00671 MpegTSWrite *ts = s->priv_data;
00672 int i;
00673
00674 if (++ts->sdt_packet_count == ts->sdt_packet_period) {
00675 ts->sdt_packet_count = 0;
00676 mpegts_write_sdt(s);
00677 }
00678 if (++ts->pat_packet_count == ts->pat_packet_period || force_pat) {
00679 ts->pat_packet_count = 0;
00680 mpegts_write_pat(s);
00681 for(i = 0; i < ts->nb_services; i++) {
00682 mpegts_write_pmt(s, ts->services[i]);
00683 }
00684 }
00685 }
00686
00687 static int write_pcr_bits(uint8_t *buf, int64_t pcr)
00688 {
00689 int64_t pcr_low = pcr % 300, pcr_high = pcr / 300;
00690
00691 *buf++ = pcr_high >> 25;
00692 *buf++ = pcr_high >> 17;
00693 *buf++ = pcr_high >> 9;
00694 *buf++ = pcr_high >> 1;
00695 *buf++ = pcr_high << 7 | pcr_low >> 8 | 0x7e;
00696 *buf++ = pcr_low;
00697
00698 return 6;
00699 }
00700
00701
00702 static void mpegts_insert_null_packet(AVFormatContext *s)
00703 {
00704 uint8_t *q;
00705 uint8_t buf[TS_PACKET_SIZE];
00706
00707 q = buf;
00708 *q++ = 0x47;
00709 *q++ = 0x00 | 0x1f;
00710 *q++ = 0xff;
00711 *q++ = 0x10;
00712 memset(q, 0x0FF, TS_PACKET_SIZE - (q - buf));
00713 mpegts_prefix_m2ts_header(s);
00714 avio_write(s->pb, buf, TS_PACKET_SIZE);
00715 }
00716
00717
00718 static void mpegts_insert_pcr_only(AVFormatContext *s, AVStream *st)
00719 {
00720 MpegTSWrite *ts = s->priv_data;
00721 MpegTSWriteStream *ts_st = st->priv_data;
00722 uint8_t *q;
00723 uint8_t buf[TS_PACKET_SIZE];
00724
00725 q = buf;
00726 *q++ = 0x47;
00727 *q++ = ts_st->pid >> 8;
00728 *q++ = ts_st->pid;
00729 *q++ = 0x20 | ts_st->cc;
00730
00731 *q++ = TS_PACKET_SIZE - 5;
00732 *q++ = 0x10;
00733
00734
00735 q += write_pcr_bits(q, get_pcr(ts, s->pb));
00736
00737
00738 memset(q, 0xFF, TS_PACKET_SIZE - (q - buf));
00739 mpegts_prefix_m2ts_header(s);
00740 avio_write(s->pb, buf, TS_PACKET_SIZE);
00741 }
00742
00743 static void write_pts(uint8_t *q, int fourbits, int64_t pts)
00744 {
00745 int val;
00746
00747 val = fourbits << 4 | (((pts >> 30) & 0x07) << 1) | 1;
00748 *q++ = val;
00749 val = (((pts >> 15) & 0x7fff) << 1) | 1;
00750 *q++ = val >> 8;
00751 *q++ = val;
00752 val = (((pts) & 0x7fff) << 1) | 1;
00753 *q++ = val >> 8;
00754 *q++ = val;
00755 }
00756
00757
00758 static void set_af_flag(uint8_t *pkt, int flag)
00759 {
00760
00761 assert(flag);
00762
00763 if ((pkt[3] & 0x20) == 0) {
00764
00765 pkt[3] |= 0x20;
00766
00767 pkt[4] = 1;
00768 pkt[5] = 0;
00769 }
00770 pkt[5] |= flag;
00771 }
00772
00773
00774 static void extend_af(uint8_t *pkt, int size)
00775 {
00776
00777 assert(pkt[3] & 0x20);
00778 pkt[4] += size;
00779 }
00780
00781
00782 static uint8_t *get_ts_payload_start(uint8_t *pkt)
00783 {
00784 if (pkt[3] & 0x20)
00785 return pkt + 5 + pkt[4];
00786 else
00787 return pkt + 4;
00788 }
00789
00790
00791
00792
00793
00794
00795 static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
00796 const uint8_t *payload, int payload_size,
00797 int64_t pts, int64_t dts, int key)
00798 {
00799 MpegTSWriteStream *ts_st = st->priv_data;
00800 MpegTSWrite *ts = s->priv_data;
00801 uint8_t buf[TS_PACKET_SIZE];
00802 uint8_t *q;
00803 int val, is_start, len, header_len, write_pcr, private_code, flags;
00804 int afc_len, stuffing_len;
00805 int64_t pcr = -1;
00806 int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE);
00807 int force_pat = st->codec->codec_type == AVMEDIA_TYPE_VIDEO && key && !ts_st->prev_payload_key;
00808
00809 is_start = 1;
00810 while (payload_size > 0) {
00811 retransmit_si_info(s, force_pat);
00812 force_pat = 0;
00813
00814 write_pcr = 0;
00815 if (ts_st->pid == ts_st->service->pcr_pid) {
00816 if (ts->mux_rate > 1 || is_start)
00817 ts_st->service->pcr_packet_count++;
00818 if (ts_st->service->pcr_packet_count >=
00819 ts_st->service->pcr_packet_period) {
00820 ts_st->service->pcr_packet_count = 0;
00821 write_pcr = 1;
00822 }
00823 }
00824
00825 if (ts->mux_rate > 1 && dts != AV_NOPTS_VALUE &&
00826 (dts - get_pcr(ts, s->pb)/300) > delay) {
00827
00828 if (write_pcr)
00829 mpegts_insert_pcr_only(s, st);
00830 else
00831 mpegts_insert_null_packet(s);
00832 continue;
00833 }
00834
00835
00836 q = buf;
00837 *q++ = 0x47;
00838 val = (ts_st->pid >> 8);
00839 if (is_start)
00840 val |= 0x40;
00841 *q++ = val;
00842 *q++ = ts_st->pid;
00843 ts_st->cc = (ts_st->cc + 1) & 0xf;
00844 *q++ = 0x10 | ts_st->cc;
00845 if (key && is_start && pts != AV_NOPTS_VALUE) {
00846
00847 if (ts_st->pid == ts_st->service->pcr_pid)
00848 write_pcr = 1;
00849 set_af_flag(buf, 0x40);
00850 q = get_ts_payload_start(buf);
00851 }
00852 if (write_pcr) {
00853 set_af_flag(buf, 0x10);
00854 q = get_ts_payload_start(buf);
00855
00856 if (ts->mux_rate > 1)
00857 pcr = get_pcr(ts, s->pb);
00858 else
00859 pcr = (dts - delay)*300;
00860 if (dts != AV_NOPTS_VALUE && dts < pcr / 300)
00861 av_log(s, AV_LOG_WARNING, "dts < pcr, TS is invalid\n");
00862 extend_af(buf, write_pcr_bits(q, pcr));
00863 q = get_ts_payload_start(buf);
00864 }
00865 if (is_start) {
00866 int pes_extension = 0;
00867
00868 *q++ = 0x00;
00869 *q++ = 0x00;
00870 *q++ = 0x01;
00871 private_code = 0;
00872 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
00873 if (st->codec->codec_id == CODEC_ID_DIRAC) {
00874 *q++ = 0xfd;
00875 } else
00876 *q++ = 0xe0;
00877 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
00878 (st->codec->codec_id == CODEC_ID_MP2 ||
00879 st->codec->codec_id == CODEC_ID_MP3 ||
00880 st->codec->codec_id == CODEC_ID_AAC)) {
00881 *q++ = 0xc0;
00882 } else {
00883 *q++ = 0xbd;
00884 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
00885 private_code = 0x20;
00886 }
00887 }
00888 header_len = 0;
00889 flags = 0;
00890 if (pts != AV_NOPTS_VALUE) {
00891 header_len += 5;
00892 flags |= 0x80;
00893 }
00894 if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
00895 header_len += 5;
00896 flags |= 0x40;
00897 }
00898 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
00899 st->codec->codec_id == CODEC_ID_DIRAC) {
00900
00901 pes_extension = 1;
00902 flags |= 0x01;
00903
00904
00905
00906
00907
00908
00909 header_len += 3;
00910 }
00911 len = payload_size + header_len + 3;
00912 if (private_code != 0)
00913 len++;
00914 if (len > 0xffff)
00915 len = 0;
00916 *q++ = len >> 8;
00917 *q++ = len;
00918 val = 0x80;
00919
00920 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
00921 val |= 0x04;
00922 *q++ = val;
00923 *q++ = flags;
00924 *q++ = header_len;
00925 if (pts != AV_NOPTS_VALUE) {
00926 write_pts(q, flags >> 6, pts);
00927 q += 5;
00928 }
00929 if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
00930 write_pts(q, 1, dts);
00931 q += 5;
00932 }
00933 if (pes_extension && st->codec->codec_id == CODEC_ID_DIRAC) {
00934 flags = 0x01;
00935 *q++ = flags;
00936 *q++ = 0x80 | 0x01;
00937
00938
00939
00940
00941 *q++ = 0x00 | 0x60;
00942 }
00943 if (private_code != 0)
00944 *q++ = private_code;
00945 is_start = 0;
00946 }
00947
00948 header_len = q - buf;
00949
00950 len = TS_PACKET_SIZE - header_len;
00951 if (len > payload_size)
00952 len = payload_size;
00953 stuffing_len = TS_PACKET_SIZE - header_len - len;
00954 if (stuffing_len > 0) {
00955
00956 if (buf[3] & 0x20) {
00957
00958 afc_len = buf[4] + 1;
00959 memmove(buf + 4 + afc_len + stuffing_len,
00960 buf + 4 + afc_len,
00961 header_len - (4 + afc_len));
00962 buf[4] += stuffing_len;
00963 memset(buf + 4 + afc_len, 0xff, stuffing_len);
00964 } else {
00965
00966 memmove(buf + 4 + stuffing_len, buf + 4, header_len - 4);
00967 buf[3] |= 0x20;
00968 buf[4] = stuffing_len - 1;
00969 if (stuffing_len >= 2) {
00970 buf[5] = 0x00;
00971 memset(buf + 6, 0xff, stuffing_len - 2);
00972 }
00973 }
00974 }
00975 memcpy(buf + TS_PACKET_SIZE - len, payload, len);
00976 payload += len;
00977 payload_size -= len;
00978 mpegts_prefix_m2ts_header(s);
00979 avio_write(s->pb, buf, TS_PACKET_SIZE);
00980 }
00981 avio_flush(s->pb);
00982 ts_st->prev_payload_key = key;
00983 }
00984
00985 static int mpegts_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
00986 {
00987 AVStream *st = s->streams[pkt->stream_index];
00988 int size = pkt->size;
00989 uint8_t *buf= pkt->data;
00990 uint8_t *data= NULL;
00991 MpegTSWrite *ts = s->priv_data;
00992 MpegTSWriteStream *ts_st = st->priv_data;
00993 const int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE)*2;
00994 int64_t dts = AV_NOPTS_VALUE, pts = AV_NOPTS_VALUE;
00995
00996 if (ts->reemit_pat_pmt) {
00997 ts->pat_packet_count = ts->pat_packet_period - 1;
00998 ts->sdt_packet_count = ts->sdt_packet_period - 1;
00999 ts->reemit_pat_pmt = 0;
01000 }
01001
01002 if (pkt->pts != AV_NOPTS_VALUE)
01003 pts = pkt->pts + delay;
01004 if (pkt->dts != AV_NOPTS_VALUE)
01005 dts = pkt->dts + delay;
01006
01007 if (ts_st->first_pts_check && pts == AV_NOPTS_VALUE) {
01008 av_log(s, AV_LOG_ERROR, "first pts value must set\n");
01009 return AVERROR_INVALIDDATA;
01010 }
01011 ts_st->first_pts_check = 0;
01012
01013 if (st->codec->codec_id == CODEC_ID_H264) {
01014 const uint8_t *p = buf, *buf_end = p+size;
01015 uint32_t state = -1;
01016
01017 if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001) {
01018 av_log(s, AV_LOG_ERROR, "H.264 bitstream malformed, "
01019 "no startcode found, use the h264_mp4toannexb bitstream filter (-bsf h264_mp4toannexb)\n");
01020 return AVERROR_INVALIDDATA;
01021 }
01022
01023 do {
01024 p = avpriv_mpv_find_start_code(p, buf_end, &state);
01025
01026 } while (p < buf_end && (state & 0x1f) != 9 &&
01027 (state & 0x1f) != 5 && (state & 0x1f) != 1);
01028
01029 if ((state & 0x1f) != 9) {
01030 data = av_malloc(pkt->size+6);
01031 if (!data)
01032 return AVERROR(ENOMEM);
01033 memcpy(data+6, pkt->data, pkt->size);
01034 AV_WB32(data, 0x00000001);
01035 data[4] = 0x09;
01036 data[5] = 0xf0;
01037 buf = data;
01038 size = pkt->size+6;
01039 }
01040 } else if (st->codec->codec_id == CODEC_ID_AAC) {
01041 if (pkt->size < 2)
01042 return AVERROR_INVALIDDATA;
01043 if ((AV_RB16(pkt->data) & 0xfff0) != 0xfff0) {
01044 ADTSContext *adts = ts_st->adts;
01045 int new_size, err;
01046 if (!adts) {
01047 av_log(s, AV_LOG_ERROR, "AAC bitstream not in ADTS format "
01048 "and extradata missing\n");
01049 return AVERROR_INVALIDDATA;
01050 }
01051 new_size = ADTS_HEADER_SIZE+adts->pce_size+pkt->size;
01052 if ((unsigned)new_size >= INT_MAX)
01053 return AVERROR_INVALIDDATA;
01054 data = av_malloc(new_size);
01055 if (!data)
01056 return AVERROR(ENOMEM);
01057 err = ff_adts_write_frame_header(adts, data, pkt->size,
01058 adts->pce_size);
01059 if (err < 0) {
01060 av_free(data);
01061 return err;
01062 }
01063 if (adts->pce_size) {
01064 memcpy(data+ADTS_HEADER_SIZE, adts->pce_data, adts->pce_size);
01065 adts->pce_size = 0;
01066 }
01067 memcpy(data+ADTS_HEADER_SIZE+adts->pce_size, pkt->data, pkt->size);
01068 buf = data;
01069 size = new_size;
01070 }
01071 }
01072
01073 if (pkt->dts != AV_NOPTS_VALUE) {
01074 int i;
01075 for(i=0; i<s->nb_streams; i++){
01076 AVStream *st2 = s->streams[i];
01077 MpegTSWriteStream *ts_st2 = st2->priv_data;
01078 if( ts_st2->payload_size
01079 && ts_st2->payload_dts == AV_NOPTS_VALUE || dts - ts_st2->payload_dts > delay/2){
01080 mpegts_write_pes(s, st2, ts_st2->payload, ts_st2->payload_size,
01081 ts_st2->payload_pts, ts_st2->payload_dts,
01082 ts_st2->payload_flags & AV_PKT_FLAG_KEY);
01083 ts_st2->payload_size = 0;
01084 }
01085 }
01086 }
01087
01088 if (ts_st->payload_size && ts_st->payload_size + size > ts->pes_payload_size) {
01089 mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size,
01090 ts_st->payload_pts, ts_st->payload_dts,
01091 ts_st->payload_flags & AV_PKT_FLAG_KEY);
01092 ts_st->payload_size = 0;
01093 }
01094
01095 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO || size > ts->pes_payload_size) {
01096 av_assert0(!ts_st->payload_size);
01097
01098 mpegts_write_pes(s, st, buf, size, pts, dts, pkt->flags & AV_PKT_FLAG_KEY);
01099 av_free(data);
01100 return 0;
01101 }
01102
01103 if (!ts_st->payload_size) {
01104 ts_st->payload_pts = pts;
01105 ts_st->payload_dts = dts;
01106 ts_st->payload_flags = pkt->flags;
01107 }
01108
01109 memcpy(ts_st->payload + ts_st->payload_size, buf, size);
01110 ts_st->payload_size += size;
01111
01112 av_free(data);
01113
01114 return 0;
01115 }
01116
01117 static void mpegts_write_flush(AVFormatContext *s)
01118 {
01119 int i;
01120
01121
01122 for(i = 0; i < s->nb_streams; i++) {
01123 AVStream *st = s->streams[i];
01124 MpegTSWriteStream *ts_st = st->priv_data;
01125 if (ts_st->payload_size > 0) {
01126 mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size,
01127 ts_st->payload_pts, ts_st->payload_dts,
01128 ts_st->payload_flags & AV_PKT_FLAG_KEY);
01129 ts_st->payload_size = 0;
01130 }
01131 }
01132 avio_flush(s->pb);
01133 }
01134
01135 static int mpegts_write_packet(AVFormatContext *s, AVPacket *pkt)
01136 {
01137 if (!pkt) {
01138 mpegts_write_flush(s);
01139 return 1;
01140 } else {
01141 return mpegts_write_packet_internal(s, pkt);
01142 }
01143 }
01144
01145 static int mpegts_write_end(AVFormatContext *s)
01146 {
01147 MpegTSWrite *ts = s->priv_data;
01148 MpegTSService *service;
01149 int i;
01150
01151 mpegts_write_flush(s);
01152
01153 for(i = 0; i < s->nb_streams; i++) {
01154 AVStream *st = s->streams[i];
01155 MpegTSWriteStream *ts_st = st->priv_data;
01156 av_freep(&ts_st->payload);
01157 av_freep(&ts_st->adts);
01158 }
01159
01160 for(i = 0; i < ts->nb_services; i++) {
01161 service = ts->services[i];
01162 av_freep(&service->provider_name);
01163 av_freep(&service->name);
01164 av_free(service);
01165 }
01166 av_free(ts->services);
01167
01168 return 0;
01169 }
01170
01171 AVOutputFormat ff_mpegts_muxer = {
01172 .name = "mpegts",
01173 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
01174 .mime_type = "video/x-mpegts",
01175 .extensions = "ts,m2t,m2ts,mts",
01176 .priv_data_size = sizeof(MpegTSWrite),
01177 .audio_codec = CODEC_ID_MP2,
01178 .video_codec = CODEC_ID_MPEG2VIDEO,
01179 .write_header = mpegts_write_header,
01180 .write_packet = mpegts_write_packet,
01181 .write_trailer = mpegts_write_end,
01182 .flags = AVFMT_ALLOW_FLUSH,
01183 .priv_class = &mpegts_muxer_class,
01184 };