FFmpeg: libavformat/mpegtsenc.c Source File

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 "libavcodec/mpegvideo.h"
00025 #include "avformat.h"
00026 #include "internal.h"
00027 #include "mpegts.h"
00028 #include "adts.h"
00029 
00030 #define PCR_TIME_BASE 27000000
00031 
00032 /* write DVB SI sections */
00033 
00034 /*********************************************/
00035 /* mpegts section writer */
00036 
00037 typedef struct MpegTSSection {
00038     int pid;
00039     int cc;
00040     void (*write_packet)(struct MpegTSSection *s, const uint8_t *packet);
00041     void *opaque;
00042 } MpegTSSection;
00043 
00044 typedef struct MpegTSService {
00045     MpegTSSection pmt; /* MPEG2 pmt table context */
00046     int sid;           /* service ID */
00047     char *name;
00048     char *provider_name;
00049     int pcr_pid;
00050     int pcr_packet_count;
00051     int pcr_packet_period;
00052 } MpegTSService;
00053 
00054 typedef struct MpegTSWrite {
00055     MpegTSSection pat; /* MPEG2 pat table */
00056     MpegTSSection sdt; /* MPEG2 sdt table context */
00057     MpegTSService **services;
00058     int sdt_packet_count;
00059     int sdt_packet_period;
00060     int pat_packet_count;
00061     int pat_packet_period;
00062     int nb_services;
00063     int onid;
00064     int tsid;
00065     int64_t first_pcr;
00066     int mux_rate; 
00067 } MpegTSWrite;
00068 
00069 /* NOTE: 4 bytes must be left at the end for the crc32 */
00070 static void mpegts_write_section(MpegTSSection *s, uint8_t *buf, int len)
00071 {
00072     MpegTSWrite *ts = ((AVFormatContext*)s->opaque)->priv_data;
00073     unsigned int crc;
00074     unsigned char packet[TS_PACKET_SIZE];
00075     const unsigned char *buf_ptr;
00076     unsigned char *q;
00077     int first, b, len1, left;
00078 
00079     crc = av_bswap32(av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, buf, len - 4));
00080     buf[len - 4] = (crc >> 24) & 0xff;
00081     buf[len - 3] = (crc >> 16) & 0xff;
00082     buf[len - 2] = (crc >> 8) & 0xff;
00083     buf[len - 1] = (crc) & 0xff;
00084 
00085     /* send each packet */
00086     buf_ptr = buf;
00087     while (len > 0) {
00088         first = (buf == buf_ptr);
00089         q = packet;
00090         *q++ = 0x47;
00091         b = (s->pid >> 8);
00092         if (first)
00093             b |= 0x40;
00094         *q++ = b;
00095         *q++ = s->pid;
00096         s->cc = (s->cc + 1) & 0xf;
00097         *q++ = 0x10 | s->cc;
00098         if (first)
00099             *q++ = 0; /* 0 offset */
00100         len1 = TS_PACKET_SIZE - (q - packet);
00101         if (len1 > len)
00102             len1 = len;
00103         memcpy(q, buf_ptr, len1);
00104         q += len1;
00105         /* add known padding data */
00106         left = TS_PACKET_SIZE - (q - packet);
00107         if (left > 0)
00108             memset(q, 0xff, left);
00109 
00110         s->write_packet(s, packet);
00111 
00112         buf_ptr += len1;
00113         len -= len1;
00114     }
00115 }
00116 
00117 static inline void put16(uint8_t **q_ptr, int val)
00118 {
00119     uint8_t *q;
00120     q = *q_ptr;
00121     *q++ = val >> 8;
00122     *q++ = val;
00123     *q_ptr = q;
00124 }
00125 
00126 static int mpegts_write_section1(MpegTSSection *s, int tid, int id,
00127                           int version, int sec_num, int last_sec_num,
00128                           uint8_t *buf, int len)
00129 {
00130     uint8_t section[1024], *q;
00131     unsigned int tot_len;
00132 
00133     tot_len = 3 + 5 + len + 4;
00134     /* check if not too big */
00135     if (tot_len > 1024)
00136         return -1;
00137 
00138     q = section;
00139     *q++ = tid;
00140     put16(&q, 0xb000 | (len + 5 + 4)); /* 5 byte header + 4 byte CRC */
00141     put16(&q, id);
00142     *q++ = 0xc1 | (version << 1); /* current_next_indicator = 1 */
00143     *q++ = sec_num;
00144     *q++ = last_sec_num;
00145     memcpy(q, buf, len);
00146 
00147     mpegts_write_section(s, section, tot_len);
00148     return 0;
00149 }
00150 
00151 /*********************************************/
00152 /* mpegts writer */
00153 
00154 #define DEFAULT_PMT_START_PID   0x1000
00155 #define DEFAULT_START_PID       0x0100
00156 #define DEFAULT_PROVIDER_NAME   "FFmpeg"
00157 #define DEFAULT_SERVICE_NAME    "Service01"
00158 
00159 /* default network id, transport stream and service identifiers */
00160 #define DEFAULT_ONID            0x0001
00161 #define DEFAULT_TSID            0x0001
00162 #define DEFAULT_SID             0x0001
00163 
00164 /* a PES packet header is generated every DEFAULT_PES_HEADER_FREQ packets */
00165 #define DEFAULT_PES_HEADER_FREQ 16
00166 #define DEFAULT_PES_PAYLOAD_SIZE ((DEFAULT_PES_HEADER_FREQ - 1) * 184 + 170)
00167 
00168 /* we retransmit the SI info at this rate */
00169 #define SDT_RETRANS_TIME 500
00170 #define PAT_RETRANS_TIME 100
00171 #define PCR_RETRANS_TIME 20
00172 
00173 typedef struct MpegTSWriteStream {
00174     struct MpegTSService *service;
00175     int pid; /* stream associated pid */
00176     int cc;
00177     int payload_index;
00178     int first_pts_check; 
00179     int64_t payload_pts;
00180     int64_t payload_dts;
00181     uint8_t payload[DEFAULT_PES_PAYLOAD_SIZE];
00182     ADTSContext *adts;
00183 } MpegTSWriteStream;
00184 
00185 static void mpegts_write_pat(AVFormatContext *s)
00186 {
00187     MpegTSWrite *ts = s->priv_data;
00188     MpegTSService *service;
00189     uint8_t data[1012], *q;
00190     int i;
00191 
00192     q = data;
00193     for(i = 0; i < ts->nb_services; i++) {
00194         service = ts->services[i];
00195         put16(&q, service->sid);
00196         put16(&q, 0xe000 | service->pmt.pid);
00197     }
00198     mpegts_write_section1(&ts->pat, PAT_TID, ts->tsid, 0, 0, 0,
00199                           data, q - data);
00200 }
00201 
00202 static void mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
00203 {
00204     //    MpegTSWrite *ts = s->priv_data;
00205     uint8_t data[1012], *q, *desc_length_ptr, *program_info_length_ptr;
00206     int val, stream_type, i;
00207 
00208     q = data;
00209     put16(&q, 0xe000 | service->pcr_pid);
00210 
00211     program_info_length_ptr = q;
00212     q += 2; /* patched after */
00213 
00214     /* put program info here */
00215 
00216     val = 0xf000 | (q - program_info_length_ptr - 2);
00217     program_info_length_ptr[0] = val >> 8;
00218     program_info_length_ptr[1] = val;
00219 
00220     for(i = 0; i < s->nb_streams; i++) {
00221         AVStream *st = s->streams[i];
00222         MpegTSWriteStream *ts_st = st->priv_data;
00223         AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL,0);
00224         switch(st->codec->codec_id) {
00225         case CODEC_ID_MPEG1VIDEO:
00226         case CODEC_ID_MPEG2VIDEO:
00227             stream_type = STREAM_TYPE_VIDEO_MPEG2;
00228             break;
00229         case CODEC_ID_MPEG4:
00230             stream_type = STREAM_TYPE_VIDEO_MPEG4;
00231             break;
00232         case CODEC_ID_H264:
00233             stream_type = STREAM_TYPE_VIDEO_H264;
00234             break;
00235         case CODEC_ID_DIRAC:
00236             stream_type = STREAM_TYPE_VIDEO_DIRAC;
00237             break;
00238         case CODEC_ID_MP2:
00239         case CODEC_ID_MP3:
00240             stream_type = STREAM_TYPE_AUDIO_MPEG1;
00241             break;
00242         case CODEC_ID_AAC:
00243             stream_type = STREAM_TYPE_AUDIO_AAC;
00244             break;
00245         case CODEC_ID_AC3:
00246             stream_type = STREAM_TYPE_AUDIO_AC3;
00247             break;
00248         default:
00249             stream_type = STREAM_TYPE_PRIVATE_DATA;
00250             break;
00251         }
00252         *q++ = stream_type;
00253         put16(&q, 0xe000 | ts_st->pid);
00254         desc_length_ptr = q;
00255         q += 2; /* patched after */
00256 
00257         /* write optional descriptors here */
00258         switch(st->codec->codec_type) {
00259         case AVMEDIA_TYPE_AUDIO:
00260             if (lang && strlen(lang->value) == 3) {
00261                 *q++ = 0x0a; /* ISO 639 language descriptor */
00262                 *q++ = 4;
00263                 *q++ = lang->value[0];
00264                 *q++ = lang->value[1];
00265                 *q++ = lang->value[2];
00266                 *q++ = 0; /* undefined type */
00267             }
00268             break;
00269         case AVMEDIA_TYPE_SUBTITLE:
00270             {
00271                 const char *language;
00272                 language = lang && strlen(lang->value)==3 ? lang->value : "eng";
00273                 *q++ = 0x59;
00274                 *q++ = 8;
00275                 *q++ = language[0];
00276                 *q++ = language[1];
00277                 *q++ = language[2];
00278                 *q++ = 0x10; /* normal subtitles (0x20 = if hearing pb) */
00279                 if(st->codec->extradata_size == 4) {
00280                     memcpy(q, st->codec->extradata, 4);
00281                     q += 4;
00282                 } else {
00283                     put16(&q, 1); /* page id */
00284                     put16(&q, 1); /* ancillary page id */
00285                 }
00286             }
00287             break;
00288         case AVMEDIA_TYPE_VIDEO:
00289             if (stream_type == STREAM_TYPE_VIDEO_DIRAC) {
00290                 *q++ = 0x05; /*MPEG-2 registration descriptor*/
00291                 *q++ = 4;
00292                 *q++ = 'd';
00293                 *q++ = 'r';
00294                 *q++ = 'a';
00295                 *q++ = 'c';
00296             }
00297             break;
00298         }
00299 
00300         val = 0xf000 | (q - desc_length_ptr - 2);
00301         desc_length_ptr[0] = val >> 8;
00302         desc_length_ptr[1] = val;
00303     }
00304     mpegts_write_section1(&service->pmt, PMT_TID, service->sid, 0, 0, 0,
00305                           data, q - data);
00306 }
00307 
00308 /* NOTE: str == NULL is accepted for an empty string */
00309 static void putstr8(uint8_t **q_ptr, const char *str)
00310 {
00311     uint8_t *q;
00312     int len;
00313 
00314     q = *q_ptr;
00315     if (!str)
00316         len = 0;
00317     else
00318         len = strlen(str);
00319     *q++ = len;
00320     memcpy(q, str, len);
00321     q += len;
00322     *q_ptr = q;
00323 }
00324 
00325 static void mpegts_write_sdt(AVFormatContext *s)
00326 {
00327     MpegTSWrite *ts = s->priv_data;
00328     MpegTSService *service;
00329     uint8_t data[1012], *q, *desc_list_len_ptr, *desc_len_ptr;
00330     int i, running_status, free_ca_mode, val;
00331 
00332     q = data;
00333     put16(&q, ts->onid);
00334     *q++ = 0xff;
00335     for(i = 0; i < ts->nb_services; i++) {
00336         service = ts->services[i];
00337         put16(&q, service->sid);
00338         *q++ = 0xfc | 0x00; /* currently no EIT info */
00339         desc_list_len_ptr = q;
00340         q += 2;
00341         running_status = 4; /* running */
00342         free_ca_mode = 0;
00343 
00344         /* write only one descriptor for the service name and provider */
00345         *q++ = 0x48;
00346         desc_len_ptr = q;
00347         q++;
00348         *q++ = 0x01; /* digital television service */
00349         putstr8(&q, service->provider_name);
00350         putstr8(&q, service->name);
00351         desc_len_ptr[0] = q - desc_len_ptr - 1;
00352 
00353         /* fill descriptor length */
00354         val = (running_status << 13) | (free_ca_mode << 12) |
00355             (q - desc_list_len_ptr - 2);
00356         desc_list_len_ptr[0] = val >> 8;
00357         desc_list_len_ptr[1] = val;
00358     }
00359     mpegts_write_section1(&ts->sdt, SDT_TID, ts->tsid, 0, 0, 0,
00360                           data, q - data);
00361 }
00362 
00363 static MpegTSService *mpegts_add_service(MpegTSWrite *ts,
00364                                          int sid,
00365                                          const char *provider_name,
00366                                          const char *name)
00367 {
00368     MpegTSService *service;
00369 
00370     service = av_mallocz(sizeof(MpegTSService));
00371     if (!service)
00372         return NULL;
00373     service->pmt.pid = DEFAULT_PMT_START_PID + ts->nb_services - 1;
00374     service->sid = sid;
00375     service->provider_name = av_strdup(provider_name);
00376     service->name = av_strdup(name);
00377     service->pcr_pid = 0x1fff;
00378     dynarray_add(&ts->services, &ts->nb_services, service);
00379     return service;
00380 }
00381 
00382 static void section_write_packet(MpegTSSection *s, const uint8_t *packet)
00383 {
00384     AVFormatContext *ctx = s->opaque;
00385     put_buffer(ctx->pb, packet, TS_PACKET_SIZE);
00386 }
00387 
00388 static int mpegts_write_header(AVFormatContext *s)
00389 {
00390     MpegTSWrite *ts = s->priv_data;
00391     MpegTSWriteStream *ts_st;
00392     MpegTSService *service;
00393     AVStream *st, *pcr_st = NULL;
00394     AVMetadataTag *title;
00395     int i, j;
00396     const char *service_name;
00397     int *pids;
00398 
00399     ts->tsid = DEFAULT_TSID;
00400     ts->onid = DEFAULT_ONID;
00401     /* allocate a single DVB service */
00402     title = av_metadata_get(s->metadata, "title", NULL, 0);
00403     service_name = title ? title->value : DEFAULT_SERVICE_NAME;
00404     service = mpegts_add_service(ts, DEFAULT_SID,
00405                                  DEFAULT_PROVIDER_NAME, service_name);
00406     service->pmt.write_packet = section_write_packet;
00407     service->pmt.opaque = s;
00408     service->pmt.cc = 15;
00409 
00410     ts->pat.pid = PAT_PID;
00411     ts->pat.cc = 15; // Initialize at 15 so that it wraps and be equal to 0 for the first packet we write
00412     ts->pat.write_packet = section_write_packet;
00413     ts->pat.opaque = s;
00414 
00415     ts->sdt.pid = SDT_PID;
00416     ts->sdt.cc = 15;
00417     ts->sdt.write_packet = section_write_packet;
00418     ts->sdt.opaque = s;
00419 
00420     pids = av_malloc(s->nb_streams * sizeof(*pids));
00421     if (!pids)
00422         return AVERROR(ENOMEM);
00423 
00424     /* assign pids to each stream */
00425     for(i = 0;i < s->nb_streams; i++) {
00426         st = s->streams[i];
00427         ts_st = av_mallocz(sizeof(MpegTSWriteStream));
00428         if (!ts_st)
00429             goto fail;
00430         st->priv_data = ts_st;
00431         ts_st->service = service;
00432         /* MPEG pid values < 16 are reserved. Applications which set st->id in
00433          * this range are assigned a calculated pid. */
00434         if (st->id < 16) {
00435             ts_st->pid = DEFAULT_START_PID + i;
00436         } else if (st->id < 0x1FFF) {
00437             ts_st->pid = st->id;
00438         } else {
00439             av_log(s, AV_LOG_ERROR, "Invalid stream id %d, must be less than 8191\n", st->id);
00440             goto fail;
00441         }
00442         if (ts_st->pid == service->pmt.pid) {
00443             av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid);
00444             goto fail;
00445         }
00446         for (j = 0; j < i; j++)
00447             if (pids[j] == ts_st->pid) {
00448                 av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid);
00449                 goto fail;
00450             }
00451         pids[i] = ts_st->pid;
00452         ts_st->payload_pts = AV_NOPTS_VALUE;
00453         ts_st->payload_dts = AV_NOPTS_VALUE;
00454         ts_st->first_pts_check = 1;
00455         ts_st->cc = 15;
00456         /* update PCR pid by using the first video stream */
00457         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
00458             service->pcr_pid == 0x1fff) {
00459             service->pcr_pid = ts_st->pid;
00460             pcr_st = st;
00461         }
00462         if (st->codec->codec_id == CODEC_ID_AAC &&
00463             st->codec->extradata_size > 0) {
00464             ts_st->adts = av_mallocz(sizeof(*ts_st->adts));
00465             if (!ts_st->adts)
00466                 return AVERROR(ENOMEM);
00467             if (ff_adts_decode_extradata(s, ts_st->adts, st->codec->extradata,
00468                                          st->codec->extradata_size) < 0)
00469                 return -1;
00470         }
00471     }
00472 
00473     av_free(pids);
00474 
00475     /* if no video stream, use the first stream as PCR */
00476     if (service->pcr_pid == 0x1fff && s->nb_streams > 0) {
00477         pcr_st = s->streams[0];
00478         ts_st = pcr_st->priv_data;
00479         service->pcr_pid = ts_st->pid;
00480     }
00481 
00482     ts->mux_rate = s->mux_rate ? s->mux_rate : 1;
00483 
00484     if (ts->mux_rate > 1) {
00485         service->pcr_packet_period = (ts->mux_rate * PCR_RETRANS_TIME) /
00486             (TS_PACKET_SIZE * 8 * 1000);
00487         ts->sdt_packet_period      = (ts->mux_rate * SDT_RETRANS_TIME) /
00488             (TS_PACKET_SIZE * 8 * 1000);
00489         ts->pat_packet_period      = (ts->mux_rate * PAT_RETRANS_TIME) /
00490             (TS_PACKET_SIZE * 8 * 1000);
00491 
00492         ts->first_pcr = av_rescale(s->max_delay, PCR_TIME_BASE, AV_TIME_BASE);
00493     } else {
00494         /* Arbitrary values, PAT/PMT could be written on key frames */
00495         ts->sdt_packet_period = 200;
00496         ts->pat_packet_period = 40;
00497         if (pcr_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
00498             if (!pcr_st->codec->frame_size) {
00499                 av_log(s, AV_LOG_WARNING, "frame size not set\n");
00500                 service->pcr_packet_period =
00501                     pcr_st->codec->sample_rate/(10*512);
00502             } else {
00503                 service->pcr_packet_period =
00504                     pcr_st->codec->sample_rate/(10*pcr_st->codec->frame_size);
00505             }
00506         } else {
00507             // max delta PCR 0.1s
00508             service->pcr_packet_period =
00509                 pcr_st->codec->time_base.den/(10*pcr_st->codec->time_base.num);
00510         }
00511     }
00512 
00513     // output a PCR as soon as possible
00514     service->pcr_packet_count = service->pcr_packet_period;
00515     ts->pat_packet_count = ts->pat_packet_period-1;
00516     ts->sdt_packet_count = ts->sdt_packet_period-1;
00517 
00518     if (ts->mux_rate == 1)
00519         av_log(s, AV_LOG_INFO, "muxrate VBR, ");
00520     else
00521         av_log(s, AV_LOG_INFO, "muxrate %d, ", ts->mux_rate);
00522     av_log(s, AV_LOG_INFO, "pcr every %d pkts, "
00523            "sdt every %d, pat/pmt every %d pkts\n",
00524            service->pcr_packet_period,
00525            ts->sdt_packet_period, ts->pat_packet_period);
00526 
00527     put_flush_packet(s->pb);
00528 
00529     return 0;
00530 
00531  fail:
00532     av_free(pids);
00533     for(i = 0;i < s->nb_streams; i++) {
00534         st = s->streams[i];
00535         av_free(st->priv_data);
00536     }
00537     return -1;
00538 }
00539 
00540 /* send SDT, PAT and PMT tables regulary */
00541 static void retransmit_si_info(AVFormatContext *s)
00542 {
00543     MpegTSWrite *ts = s->priv_data;
00544     int i;
00545 
00546     if (++ts->sdt_packet_count == ts->sdt_packet_period) {
00547         ts->sdt_packet_count = 0;
00548         mpegts_write_sdt(s);
00549     }
00550     if (++ts->pat_packet_count == ts->pat_packet_period) {
00551         ts->pat_packet_count = 0;
00552         mpegts_write_pat(s);
00553         for(i = 0; i < ts->nb_services; i++) {
00554             mpegts_write_pmt(s, ts->services[i]);
00555         }
00556     }
00557 }
00558 
00559 static int64_t get_pcr(const MpegTSWrite *ts, ByteIOContext *pb)
00560 {
00561     return av_rescale(url_ftell(pb) + 11, 8 * PCR_TIME_BASE, ts->mux_rate) +
00562            ts->first_pcr;
00563 }
00564 
00565 static uint8_t* write_pcr_bits(uint8_t *buf, int64_t pcr)
00566 {
00567     int64_t pcr_low = pcr % 300, pcr_high = pcr / 300;
00568 
00569     *buf++ = pcr_high >> 25;
00570     *buf++ = pcr_high >> 17;
00571     *buf++ = pcr_high >> 9;
00572     *buf++ = pcr_high >> 1;
00573     *buf++ = ((pcr_high & 1) << 7) | (pcr_low >> 8);
00574     *buf++ = pcr_low;
00575 
00576     return buf;
00577 }
00578 
00579 /* Write a single null transport stream packet */
00580 static void mpegts_insert_null_packet(AVFormatContext *s)
00581 {
00582     MpegTSWrite *ts = s->priv_data;
00583     uint8_t *q;
00584     uint8_t buf[TS_PACKET_SIZE];
00585 
00586     q = buf;
00587     *q++ = 0x47;
00588     *q++ = 0x00 | 0x1f;
00589     *q++ = 0xff;
00590     *q++ = 0x10;
00591     memset(q, 0x0FF, TS_PACKET_SIZE - (q - buf));
00592     put_buffer(s->pb, buf, TS_PACKET_SIZE);
00593 }
00594 
00595 /* Write a single transport stream packet with a PCR and no payload */
00596 static void mpegts_insert_pcr_only(AVFormatContext *s, AVStream *st)
00597 {
00598     MpegTSWrite *ts = s->priv_data;
00599     MpegTSWriteStream *ts_st = st->priv_data;
00600     uint8_t *q;
00601     uint8_t buf[TS_PACKET_SIZE];
00602 
00603     q = buf;
00604     *q++ = 0x47;
00605     *q++ = ts_st->pid >> 8;
00606     *q++ = ts_st->pid;
00607     *q++ = 0x20 | ts_st->cc;   /* Adaptation only */
00608     /* Continuity Count field does not increment (see 13818-1 section 2.4.3.3) */
00609     *q++ = TS_PACKET_SIZE - 5; /* Adaptation Field Length */
00610     *q++ = 0x10;               /* Adaptation flags: PCR present */
00611 
00612     /* PCR coded into 6 bytes */
00613     q = write_pcr_bits(q, get_pcr(ts, s->pb));
00614 
00615     /* stuffing bytes */
00616     memset(q, 0xFF, TS_PACKET_SIZE - (q - buf));
00617     put_buffer(s->pb, buf, TS_PACKET_SIZE);
00618 }
00619 
00620 static void write_pts(uint8_t *q, int fourbits, int64_t pts)
00621 {
00622     int val;
00623 
00624     val = fourbits << 4 | (((pts >> 30) & 0x07) << 1) | 1;
00625     *q++ = val;
00626     val = (((pts >> 15) & 0x7fff) << 1) | 1;
00627     *q++ = val >> 8;
00628     *q++ = val;
00629     val = (((pts) & 0x7fff) << 1) | 1;
00630     *q++ = val >> 8;
00631     *q++ = val;
00632 }
00633 
00634 /* Add a pes header to the front of payload, and segment into an integer number of
00635  * ts packets. The final ts packet is padded using an over-sized adaptation header
00636  * to exactly fill the last ts packet.
00637  * NOTE: 'payload' contains a complete PES payload.
00638  */
00639 static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
00640                              const uint8_t *payload, int payload_size,
00641                              int64_t pts, int64_t dts)
00642 {
00643     MpegTSWriteStream *ts_st = st->priv_data;
00644     MpegTSWrite *ts = s->priv_data;
00645     uint8_t buf[TS_PACKET_SIZE];
00646     uint8_t *q;
00647     int val, is_start, len, header_len, write_pcr, private_code, flags;
00648     int afc_len, stuffing_len;
00649     int64_t pcr = -1; /* avoid warning */
00650     int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE);
00651 
00652     is_start = 1;
00653     while (payload_size > 0) {
00654         retransmit_si_info(s);
00655 
00656         write_pcr = 0;
00657         if (ts_st->pid == ts_st->service->pcr_pid) {
00658             if (ts->mux_rate > 1 || is_start) // VBR pcr period is based on frames
00659                 ts_st->service->pcr_packet_count++;
00660             if (ts_st->service->pcr_packet_count >=
00661                 ts_st->service->pcr_packet_period) {
00662                 ts_st->service->pcr_packet_count = 0;
00663                 write_pcr = 1;
00664             }
00665         }
00666 
00667         if (ts->mux_rate > 1 && dts != AV_NOPTS_VALUE &&
00668             (dts - get_pcr(ts, s->pb)/300) > delay) {
00669             /* pcr insert gets priority over null packet insert */
00670             if (write_pcr)
00671                 mpegts_insert_pcr_only(s, st);
00672             else
00673                 mpegts_insert_null_packet(s);
00674             continue; /* recalculate write_pcr and possibly retransmit si_info */
00675         }
00676 
00677         /* prepare packet header */
00678         q = buf;
00679         *q++ = 0x47;
00680         val = (ts_st->pid >> 8);
00681         if (is_start)
00682             val |= 0x40;
00683         *q++ = val;
00684         *q++ = ts_st->pid;
00685         ts_st->cc = (ts_st->cc + 1) & 0xf;
00686         *q++ = 0x10 | ts_st->cc | (write_pcr ? 0x20 : 0);
00687         if (write_pcr) {
00688             // add 11, pcr references the last byte of program clock reference base
00689             if (ts->mux_rate > 1)
00690                 pcr = get_pcr(ts, s->pb);
00691             else
00692                 pcr = (dts - delay)*300;
00693             if (dts != AV_NOPTS_VALUE && dts < pcr / 300)
00694                 av_log(s, AV_LOG_WARNING, "dts < pcr, TS is invalid\n");
00695             *q++ = 7; /* AFC length */
00696             *q++ = 0x10; /* flags: PCR present */
00697             q = write_pcr_bits(q, pcr);
00698         }
00699         if (is_start) {
00700             int pes_extension = 0;
00701             /* write PES header */
00702             *q++ = 0x00;
00703             *q++ = 0x00;
00704             *q++ = 0x01;
00705             private_code = 0;
00706             if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
00707                 if (st->codec->codec_id == CODEC_ID_DIRAC) {
00708                     *q++ = 0xfd;
00709                 } else
00710                     *q++ = 0xe0;
00711             } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
00712                        (st->codec->codec_id == CODEC_ID_MP2 ||
00713                         st->codec->codec_id == CODEC_ID_MP3)) {
00714                 *q++ = 0xc0;
00715             } else {
00716                 *q++ = 0xbd;
00717                 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
00718                     private_code = 0x20;
00719                 }
00720             }
00721             header_len = 0;
00722             flags = 0;
00723             if (pts != AV_NOPTS_VALUE) {
00724                 header_len += 5;
00725                 flags |= 0x80;
00726             }
00727             if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
00728                 header_len += 5;
00729                 flags |= 0x40;
00730             }
00731             if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
00732                 st->codec->codec_id == CODEC_ID_DIRAC) {
00733                 /* set PES_extension_flag */
00734                 pes_extension = 1;
00735                 flags |= 0x01;
00736 
00737                 /*
00738                 * One byte for PES2 extension flag +
00739                 * one byte for extension length +
00740                 * one byte for extension id
00741                 */
00742                 header_len += 3;
00743             }
00744             len = payload_size + header_len + 3;
00745             if (private_code != 0)
00746                 len++;
00747             if (len > 0xffff)
00748                 len = 0;
00749             *q++ = len >> 8;
00750             *q++ = len;
00751             val = 0x80;
00752             /* data alignment indicator is required for subtitle data */
00753             if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
00754                 val |= 0x04;
00755             *q++ = val;
00756             *q++ = flags;
00757             *q++ = header_len;
00758             if (pts != AV_NOPTS_VALUE) {
00759                 write_pts(q, flags >> 6, pts);
00760                 q += 5;
00761             }
00762             if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
00763                 write_pts(q, 1, dts);
00764                 q += 5;
00765             }
00766             if (pes_extension && st->codec->codec_id == CODEC_ID_DIRAC) {
00767                 flags = 0x01;  /* set PES_extension_flag_2 */
00768                 *q++ = flags;
00769                 *q++ = 0x80 | 0x01;  /* marker bit + extension length */
00770                 /*
00771                 * Set the stream id extension flag bit to 0 and
00772                 * write the extended stream id
00773                 */
00774                 *q++ = 0x00 | 0x60;
00775             }
00776             if (private_code != 0)
00777                 *q++ = private_code;
00778             is_start = 0;
00779         }
00780         /* header size */
00781         header_len = q - buf;
00782         /* data len */
00783         len = TS_PACKET_SIZE - header_len;
00784         if (len > payload_size)
00785             len = payload_size;
00786         stuffing_len = TS_PACKET_SIZE - header_len - len;
00787         if (stuffing_len > 0) {
00788             /* add stuffing with AFC */
00789             if (buf[3] & 0x20) {
00790                 /* stuffing already present: increase its size */
00791                 afc_len = buf[4] + 1;
00792                 memmove(buf + 4 + afc_len + stuffing_len,
00793                         buf + 4 + afc_len,
00794                         header_len - (4 + afc_len));
00795                 buf[4] += stuffing_len;
00796                 memset(buf + 4 + afc_len, 0xff, stuffing_len);
00797             } else {
00798                 /* add stuffing */
00799                 memmove(buf + 4 + stuffing_len, buf + 4, header_len - 4);
00800                 buf[3] |= 0x20;
00801                 buf[4] = stuffing_len - 1;
00802                 if (stuffing_len >= 2) {
00803                     buf[5] = 0x00;
00804                     memset(buf + 6, 0xff, stuffing_len - 2);
00805                 }
00806             }
00807         }
00808         memcpy(buf + TS_PACKET_SIZE - len, payload, len);
00809         payload += len;
00810         payload_size -= len;
00811         put_buffer(s->pb, buf, TS_PACKET_SIZE);
00812     }
00813     put_flush_packet(s->pb);
00814 }
00815 
00816 static int mpegts_write_packet(AVFormatContext *s, AVPacket *pkt)
00817 {
00818     AVStream *st = s->streams[pkt->stream_index];
00819     int size = pkt->size;
00820     uint8_t *buf= pkt->data;
00821     uint8_t *data= NULL;
00822     MpegTSWriteStream *ts_st = st->priv_data;
00823     const uint64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE)*2;
00824     int64_t dts = AV_NOPTS_VALUE, pts = AV_NOPTS_VALUE;
00825 
00826     if (pkt->pts != AV_NOPTS_VALUE)
00827         pts = pkt->pts + delay;
00828     if (pkt->dts != AV_NOPTS_VALUE)
00829         dts = pkt->dts + delay;
00830 
00831     if (ts_st->first_pts_check && pts == AV_NOPTS_VALUE) {
00832         av_log(s, AV_LOG_ERROR, "first pts value must set\n");
00833         return -1;
00834     }
00835     ts_st->first_pts_check = 0;
00836 
00837     if (st->codec->codec_id == CODEC_ID_H264) {
00838         const uint8_t *p = buf, *buf_end = p+size;
00839         uint32_t state = -1;
00840 
00841         if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001) {
00842             av_log(s, AV_LOG_ERROR, "h264 bitstream malformated, "
00843                    "no startcode found, use -vbsf h264_mp4toannexb\n");
00844             return -1;
00845         }
00846 
00847         do {
00848             p = ff_find_start_code(p, buf_end, &state);
00849             //av_log(s, AV_LOG_INFO, "nal %d\n", state & 0x1f);
00850         } while (p < buf_end && (state & 0x1f) != 9 &&
00851                  (state & 0x1f) != 5 && (state & 0x1f) != 1);
00852 
00853         if ((state & 0x1f) != 9) { // AUD NAL
00854             data = av_malloc(pkt->size+6);
00855             if (!data)
00856                 return -1;
00857             memcpy(data+6, pkt->data, pkt->size);
00858             AV_WB32(data, 0x00000001);
00859             data[4] = 0x09;
00860             data[5] = 0xf0; // any slice type (0xe) + rbsp stop one bit
00861             buf  = data;
00862             size = pkt->size+6;
00863         }
00864     } else if (st->codec->codec_id == CODEC_ID_AAC) {
00865         if (pkt->size < 2)
00866             return -1;
00867         if ((AV_RB16(pkt->data) & 0xfff0) != 0xfff0) {
00868             ADTSContext *adts = ts_st->adts;
00869             int new_size;
00870             if (!adts) {
00871                 av_log(s, AV_LOG_ERROR, "aac bitstream not in adts format "
00872                        "and extradata missing\n");
00873                 return -1;
00874             }
00875             new_size = ADTS_HEADER_SIZE+adts->pce_size+pkt->size;
00876             if ((unsigned)new_size >= INT_MAX)
00877                 return -1;
00878             data = av_malloc(new_size);
00879             if (!data)
00880                 return AVERROR(ENOMEM);
00881             ff_adts_write_frame_header(adts, data, pkt->size, adts->pce_size);
00882             if (adts->pce_size) {
00883                 memcpy(data+ADTS_HEADER_SIZE, adts->pce_data, adts->pce_size);
00884                 adts->pce_size = 0;
00885             }
00886             memcpy(data+ADTS_HEADER_SIZE+adts->pce_size, pkt->data, pkt->size);
00887             buf = data;
00888             size = new_size;
00889         }
00890     }
00891 
00892     if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
00893         // for video and subtitle, write a single pes packet
00894         mpegts_write_pes(s, st, buf, size, pts, dts);
00895         av_free(data);
00896         return 0;
00897     }
00898 
00899     if (ts_st->payload_index + size > DEFAULT_PES_PAYLOAD_SIZE) {
00900         mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_index,
00901                          ts_st->payload_pts, ts_st->payload_dts);
00902         ts_st->payload_index = 0;
00903     }
00904 
00905     if (!ts_st->payload_index) {
00906         ts_st->payload_pts = pts;
00907         ts_st->payload_dts = dts;
00908     }
00909 
00910     memcpy(ts_st->payload + ts_st->payload_index, buf, size);
00911     ts_st->payload_index += size;
00912 
00913     av_free(data);
00914 
00915     return 0;
00916 }
00917 
00918 static int mpegts_write_end(AVFormatContext *s)
00919 {
00920     MpegTSWrite *ts = s->priv_data;
00921     MpegTSWriteStream *ts_st;
00922     MpegTSService *service;
00923     AVStream *st;
00924     int i;
00925 
00926     /* flush current packets */
00927     for(i = 0; i < s->nb_streams; i++) {
00928         st = s->streams[i];
00929         ts_st = st->priv_data;
00930         if (ts_st->payload_index > 0) {
00931             mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_index,
00932                              ts_st->payload_pts, ts_st->payload_dts);
00933         }
00934         av_freep(&ts_st->adts);
00935     }
00936     put_flush_packet(s->pb);
00937 
00938     for(i = 0; i < ts->nb_services; i++) {
00939         service = ts->services[i];
00940         av_freep(&service->provider_name);
00941         av_freep(&service->name);
00942         av_free(service);
00943     }
00944     av_free(ts->services);
00945 
00946     return 0;
00947 }
00948 
00949 AVOutputFormat mpegts_muxer = {
00950     "mpegts",
00951     NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
00952     "video/x-mpegts",
00953     "ts,m2t",
00954     sizeof(MpegTSWrite),
00955     CODEC_ID_MP2,
00956     CODEC_ID_MPEG2VIDEO,
00957     mpegts_write_header,
00958     mpegts_write_packet,
00959     mpegts_write_end,
00960 };