mpegts: K&R formatting cosmetics

libavformat/mpegtsenc.c

@@ -25,7 +25,9 @@
 #include "libavutil/intreadwrite.h"
 #include "libavutil/mathematics.h"
 #include "libavutil/opt.h"
+
 #include "libavcodec/internal.h"
+
 #include "avformat.h"
 #include "internal.h"
 #include "mpegts.h"
@@ -102,7 +104,9 @@ static void mpegts_write_section(MpegTSSection *s, uint8_t *buf, int len)
     unsigned char *q;
     int first, b, len1, left;
 
-    crc = av_bswap32(av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, buf, len - 4));
+    crc = av_bswap32(av_crc(av_crc_get_table(AV_CRC_32_IEEE),
+                            -1, buf, len - 4));
+
     buf[len - 4] = (crc >> 24) & 0xff;
     buf[len - 3] = (crc >> 16) & 0xff;
     buf[len - 2] = (crc >>  8) & 0xff;
@@ -209,7 +213,7 @@ static void mpegts_write_pat(AVFormatContext *s)
     int i;
 
     q = data;
-    for(i = 0; i < ts->nb_services; i++) {
+    for (i = 0; i < ts->nb_services; i++) {
         service = ts->services[i];
         put16(&q, service->sid);
         put16(&q, 0xe000 | service->pmt.pid);
@@ -236,11 +240,11 @@ static void mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
     program_info_length_ptr[0] = val >> 8;
     program_info_length_ptr[1] = val;
 
-    for(i = 0; i < s->nb_streams; i++) {
+    for (i = 0; i < s->nb_streams; i++) {
         AVStream *st = s->streams[i];
         MpegTSWriteStream *ts_st = st->priv_data;
-        AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL,0);
-        switch(st->codec->codec_id) {
+        AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
+        switch (st->codec->codec_id) {
         case AV_CODEC_ID_MPEG1VIDEO:
         case AV_CODEC_ID_MPEG2VIDEO:
             stream_type = STREAM_TYPE_VIDEO_MPEG2;
@@ -265,7 +269,9 @@ static void mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
             stream_type = STREAM_TYPE_AUDIO_MPEG1;
             break;
         case AV_CODEC_ID_AAC:
-            stream_type = (ts->flags & MPEGTS_FLAG_AAC_LATM) ? STREAM_TYPE_AUDIO_AAC_LATM : STREAM_TYPE_AUDIO_AAC;
+            stream_type = (ts->flags & MPEGTS_FLAG_AAC_LATM)
+                          ? STREAM_TYPE_AUDIO_AAC_LATM
+                          : STREAM_TYPE_AUDIO_AAC;
             break;
         case AV_CODEC_ID_AAC_LATM:
             stream_type = STREAM_TYPE_AUDIO_AAC_LATM;
@@ -283,7 +289,7 @@ static void mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
         q += 2; /* patched after */
 
         /* write optional descriptors here */
-        switch(st->codec->codec_type) {
+        switch (st->codec->codec_type) {
         case AVMEDIA_TYPE_AUDIO:
             if (lang) {
                 char *p;
@@ -322,14 +328,14 @@ static void mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
         case AVMEDIA_TYPE_SUBTITLE:
         {
             const char *language;
-                language = lang && strlen(lang->value)==3 ? lang->value : "eng";
+            language = lang && strlen(lang->value) == 3 ? lang->value : "eng";
             *q++ = 0x59;
             *q++ = 8;
             *q++ = language[0];
             *q++ = language[1];
             *q++ = language[2];
             *q++ = 0x10; /* normal subtitles (0x20 = if hearing pb) */
-                if(st->codec->extradata_size == 4) {
+            if (st->codec->extradata_size == 4) {
                 memcpy(q, st->codec->extradata, 4);
                 q += 4;
             } else {
@@ -385,7 +391,7 @@ static void mpegts_write_sdt(AVFormatContext *s)
     q = data;
     put16(&q, ts->onid);
     *q++ = 0xff;
-    for(i = 0; i < ts->nb_services; i++) {
+    for (i = 0; i < ts->nb_services; i++) {
         service = ts->services[i];
         put16(&q, service->sid);
         *q++              = 0xfc | 0x00; /* currently no EIT info */
@@ -413,8 +419,7 @@ static void mpegts_write_sdt(AVFormatContext *s)
                           data, q - data);
 }
 
-static MpegTSService *mpegts_add_service(MpegTSWrite *ts,
-                                         int sid,
+static MpegTSService *mpegts_add_service(MpegTSWrite *ts, int sid,
                                          const char *provider_name,
                                          const char *name)
 {
@@ -466,13 +471,17 @@ static int mpegts_write_header(AVFormatContext *s)
     service_name  = title ? title->value : DEFAULT_SERVICE_NAME;
     provider      = av_dict_get(s->metadata, "service_provider", NULL, 0);
     provider_name = provider ? provider->value : DEFAULT_PROVIDER_NAME;
-    service = mpegts_add_service(ts, ts->service_id, provider_name, service_name);
+    service       = mpegts_add_service(ts, ts->service_id,
+                                       provider_name, service_name);
+
     service->pmt.write_packet = section_write_packet;
     service->pmt.opaque       = s;
     service->pmt.cc           = 15;
 
     ts->pat.pid          = PAT_PID;
-    ts->pat.cc = 15; // Initialize at 15 so that it wraps and be equal to 0 for the first packet we write
+    /* Initialize at 15 so that it wraps and is equal to 0 for the
+     * first packet we write. */
+    ts->pat.cc           = 15;
     ts->pat.write_packet = section_write_packet;
     ts->pat.opaque       = s;
 
@@ -486,7 +495,7 @@ static int mpegts_write_header(AVFormatContext *s)
         return AVERROR(ENOMEM);
 
     /* assign pids to each stream */
-    for(i = 0;i < s->nb_streams; i++) {
+    for (i = 0; i < s->nb_streams; i++) {
         st = s->streams[i];
 
         ts_st = av_mallocz(sizeof(MpegTSWriteStream));
@@ -512,7 +521,8 @@ static int mpegts_write_header(AVFormatContext *s)
         } else if (st->id < 0x1FFF) {
             ts_st->pid = st->id;
         } else {
-            av_log(s, AV_LOG_ERROR, "Invalid stream id %d, must be less than 8191\n", st->id);
+            av_log(s, AV_LOG_ERROR,
+                   "Invalid stream id %d, must be less than 8191\n", st->id);
             ret = AVERROR(EINVAL);
             goto fail;
         }
@@ -521,12 +531,13 @@ static int mpegts_write_header(AVFormatContext *s)
             ret = AVERROR(EINVAL);
             goto fail;
         }
-        for (j = 0; j < i; j++)
+        for (j = 0; j < i; j++) {
             if (pids[j] == ts_st->pid) {
                 av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid);
                 ret = AVERROR(EINVAL);
                 goto fail;
             }
+        }
         pids[i]                = ts_st->pid;
         ts_st->payload_pts     = AV_NOPTS_VALUE;
         ts_st->payload_dts     = AV_NOPTS_VALUE;
@@ -539,15 +550,16 @@ static int mpegts_write_header(AVFormatContext *s)
             pcr_st           = st;
         }
         if (st->codec->codec_id == AV_CODEC_ID_AAC &&
-            st->codec->extradata_size > 0)
-        {
+            st->codec->extradata_size > 0) {
             AVStream *ast;
             ts_st->amux = avformat_alloc_context();
             if (!ts_st->amux) {
                 ret = AVERROR(ENOMEM);
                 goto fail;
             }
-            ts_st->amux->oformat = av_guess_format((ts->flags & MPEGTS_FLAG_AAC_LATM) ? "latm" : "adts", NULL, NULL);
+            ts_st->amux->oformat =
+                av_guess_format((ts->flags & MPEGTS_FLAG_AAC_LATM) ? "latm" : "adts",
+                                NULL, NULL);
             if (!ts_st->amux->oformat) {
                 ret = AVERROR(EINVAL);
                 goto fail;
@@ -589,10 +601,10 @@ static int mpegts_write_header(AVFormatContext *s)
             if (!pcr_st->codec->frame_size) {
                 av_log(s, AV_LOG_WARNING, "frame size not set\n");
                 service->pcr_packet_period =
-                    pcr_st->codec->sample_rate/(10*512);
+                    pcr_st->codec->sample_rate / (10 * 512);
             } else {
                 service->pcr_packet_period =
-                    pcr_st->codec->sample_rate/(10*pcr_st->codec->frame_size);
+                    pcr_st->codec->sample_rate / (10 * pcr_st->codec->frame_size);
             }
         } else {
             // max delta PCR 0.1s
@@ -604,15 +616,15 @@ static int mpegts_write_header(AVFormatContext *s)
 
     // output a PCR as soon as possible
     service->pcr_packet_count = service->pcr_packet_period;
-    ts->pat_packet_count = ts->pat_packet_period-1;
-    ts->sdt_packet_count = ts->sdt_packet_period-1;
+    ts->pat_packet_count      = ts->pat_packet_period - 1;
+    ts->sdt_packet_count      = ts->sdt_packet_period - 1;
 
     if (ts->mux_rate == 1)
         av_log(s, AV_LOG_VERBOSE, "muxrate VBR, ");
     else
         av_log(s, AV_LOG_VERBOSE, "muxrate %d, ", ts->mux_rate);
-    av_log(s, AV_LOG_VERBOSE, "pcr every %d pkts, "
-           "sdt every %d, pat/pmt every %d pkts\n",
+    av_log(s, AV_LOG_VERBOSE,
+           "pcr every %d pkts, sdt every %d, pat/pmt every %d pkts\n",
            service->pcr_packet_period,
            ts->sdt_packet_period, ts->pat_packet_period);
 
@@ -620,9 +632,9 @@ static int mpegts_write_header(AVFormatContext *s)
 
     return 0;
 
- fail:
+fail:
     av_free(pids);
-    for(i = 0;i < s->nb_streams; i++) {
+    for (i = 0; i < s->nb_streams; i++) {
         MpegTSWriteStream *ts_st;
         st    = s->streams[i];
         ts_st = st->priv_data;
@@ -651,10 +663,9 @@ static void retransmit_si_info(AVFormatContext *s)
     if (++ts->pat_packet_count == ts->pat_packet_period) {
         ts->pat_packet_count = 0;
         mpegts_write_pat(s);
-        for(i = 0; i < ts->nb_services; i++) {
+        for (i = 0; i < ts->nb_services; i++)
             mpegts_write_pmt(s, ts->services[i]);
     }
-    }
 }
 
 static int64_t get_pcr(const MpegTSWrite *ts, AVIOContext *pb)
@@ -764,11 +775,10 @@ static uint8_t *get_ts_payload_start(uint8_t *pkt)
         return pkt + 4;
 }
 
-/* Add a pes header to the front of payload, and segment into an integer number of
- * ts packets. The final ts packet is padded using an over-sized adaptation header
- * to exactly fill the last ts packet.
- * NOTE: 'payload' contains a complete PES payload.
- */
+/* Add a PES header to the front of the payload, and segment into an integer
+ * number of TS packets. The final TS packet is padded using an oversized
+ * adaptation header to exactly fill the last TS packet.
+ * NOTE: 'payload' contains a complete PES payload. */
 static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
                              const uint8_t *payload, int payload_size,
                              int64_t pts, int64_t dts, int key)
@@ -798,13 +808,14 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
         }
 
         if (ts->mux_rate > 1 && dts != AV_NOPTS_VALUE &&
-            (dts - get_pcr(ts, s->pb)/300) > delay) {
+            (dts - get_pcr(ts, s->pb) / 300) > delay) {
             /* pcr insert gets priority over null packet insert */
             if (write_pcr)
                 mpegts_insert_pcr_only(s, st);
             else
                 mpegts_insert_null_packet(s);
-            continue; /* recalculate write_pcr and possibly retransmit si_info */
+            /* recalculate write_pcr and possibly retransmit si_info */
+            continue;
         }
 
         /* prepare packet header */
@@ -831,7 +842,7 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
             if (ts->mux_rate > 1)
                 pcr = get_pcr(ts, s->pb);
             else
-                pcr = (dts - delay)*300;
+                pcr = (dts - delay) * 300;
             if (dts != AV_NOPTS_VALUE && dts < pcr / 300)
                 av_log(s, AV_LOG_WARNING, "dts < pcr, TS is invalid\n");
             extend_af(buf, write_pcr_bits(q, pcr));
@@ -845,9 +856,9 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
             *q++ = 0x01;
             private_code = 0;
             if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
-                if (st->codec->codec_id == AV_CODEC_ID_DIRAC) {
+                if (st->codec->codec_id == AV_CODEC_ID_DIRAC)
                     *q++ = 0xfd;
-                } else
+                else
                     *q++ = 0xe0;
             } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
                        (st->codec->codec_id == AV_CODEC_ID_MP2 ||
@@ -856,10 +867,9 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
                 *q++ = 0xc0;
             } else {
                 *q++ = 0xbd;
-                if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
+                if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
                     private_code = 0x20;
             }
-            }
             header_len = 0;
             flags      = 0;
             if (pts != AV_NOPTS_VALUE) {
@@ -876,11 +886,9 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
                 pes_extension = 1;
                 flags        |= 0x01;
 
-                /*
-                * One byte for PES2 extension flag +
+                /* One byte for PES2 extension flag +
                  * one byte for extension length +
-                * one byte for extension id
-                */
+                 * one byte for extension id */
                 header_len += 3;
             }
             len = payload_size + header_len + 3;
@@ -909,10 +917,8 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
                 flags = 0x01;  /* set PES_extension_flag_2 */
                 *q++  = flags;
                 *q++  = 0x80 | 0x01; /* marker bit + extension length */
-                /*
-                * Set the stream id extension flag bit to 0 and
-                * write the extended stream id
-                */
+                /* Set the stream ID extension flag bit to 0 and
+                 * write the extended stream ID. */
                 *q++ = 0x00 | 0x60;
             }
             if (private_code != 0)
@@ -959,15 +965,16 @@ static int mpegts_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
 {
     AVStream *st = s->streams[pkt->stream_index];
     int size = pkt->size;
-    uint8_t *buf= pkt->data;
-    uint8_t *data= NULL;
+    uint8_t *buf = pkt->data;
+    uint8_t *data = NULL;
     MpegTSWrite *ts = s->priv_data;
     MpegTSWriteStream *ts_st = st->priv_data;
-    const uint64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE)*2;
+    const uint64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE) * 2;
     int64_t dts = AV_NOPTS_VALUE, pts = AV_NOPTS_VALUE;
 
     if (ts->reemit_pat_pmt) {
-        av_log(s, AV_LOG_WARNING, "resend_headers option is deprecated, use -mpegts_flags resend_headers\n");
+        av_log(s, AV_LOG_WARNING,
+               "resend_headers option is deprecated, use -mpegts_flags resend_headers\n");
         ts->reemit_pat_pmt = 0;
         ts->flags         |= MPEGTS_FLAG_REEMIT_PAT_PMT;
     }
@@ -990,7 +997,7 @@ static int mpegts_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
     ts_st->first_pts_check = 0;
 
     if (st->codec->codec_id == AV_CODEC_ID_H264) {
-        const uint8_t *p = buf, *buf_end = p+size;
+        const uint8_t *p = buf, *buf_end = p + size;
         uint32_t state = -1;
 
         if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001) {
@@ -1006,15 +1013,15 @@ static int mpegts_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
                  (state & 0x1f) != 5 && (state & 0x1f) != 1);
 
         if ((state & 0x1f) != 9) { // AUD NAL
-            data = av_malloc(pkt->size+6);
+            data = av_malloc(pkt->size + 6);
             if (!data)
                 return AVERROR(ENOMEM);
-            memcpy(data+6, pkt->data, pkt->size);
+            memcpy(data + 6, pkt->data, pkt->size);
             AV_WB32(data, 0x00000001);
             data[4] = 0x09;
             data[5] = 0xf0; // any slice type (0xe) + rbsp stop one bit
             buf     = data;
-            size = pkt->size+6;
+            size    = pkt->size + 6;
         }
     } else if (st->codec->codec_id == AV_CODEC_ID_AAC) {
         if (pkt->size < 2) {
@@ -1034,6 +1041,7 @@ static int mpegts_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
             av_init_packet(&pkt2);
             pkt2.data = pkt->data;
             pkt2.size = pkt->size;
+
             ret = avio_open_dyn_buf(&ts_st->amux->pb);
             if (ret < 0)
                 return AVERROR(ENOMEM);
@@ -1053,7 +1061,8 @@ static int mpegts_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
 
     if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
         // for video and subtitle, write a single pes packet
-        mpegts_write_pes(s, st, buf, size, pts, dts, pkt->flags & AV_PKT_FLAG_KEY);
+        mpegts_write_pes(s, st, buf, size, pts, dts,
+                         pkt->flags & AV_PKT_FLAG_KEY);
         av_free(data);
         return 0;
     }
@@ -1092,7 +1101,7 @@ static void mpegts_write_flush(AVFormatContext *s)
     int i;
 
     /* flush current packets */
-    for(i = 0; i < s->nb_streams; i++) {
+    for (i = 0; i < s->nb_streams; i++) {
         AVStream *st = s->streams[i];
         MpegTSWriteStream *ts_st = st->priv_data;
         if (ts_st->payload_size > 0) {
@@ -1123,7 +1132,7 @@ static int mpegts_write_end(AVFormatContext *s)
 
     mpegts_write_flush(s);
 
-    for(i = 0; i < s->nb_streams; i++) {
+    for (i = 0; i < s->nb_streams; i++) {
         AVStream *st = s->streams[i];
         MpegTSWriteStream *ts_st = st->priv_data;
         av_freep(&ts_st->payload);
@@ -1133,7 +1142,7 @@ static int mpegts_write_end(AVFormatContext *s)
         }
     }
 
-    for(i = 0; i < ts->nb_services; i++) {
+    for (i = 0; i < ts->nb_services; i++) {
         service = ts->services[i];
         av_freep(&service->provider_name);
         av_freep(&service->name);
@@ -1146,31 +1155,42 @@ static int mpegts_write_end(AVFormatContext *s)
 
 static const AVOption options[] = {
     { "mpegts_transport_stream_id", "Set transport_stream_id field.",
-      offsetof(MpegTSWrite, transport_stream_id), AV_OPT_TYPE_INT, {.i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
+      offsetof(MpegTSWrite, transport_stream_id), AV_OPT_TYPE_INT,
+      { .i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM },
     { "mpegts_original_network_id", "Set original_network_id field.",
-      offsetof(MpegTSWrite, original_network_id), AV_OPT_TYPE_INT, {.i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
+      offsetof(MpegTSWrite, original_network_id), AV_OPT_TYPE_INT,
+      { .i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM },
     { "mpegts_service_id", "Set service_id field.",
-      offsetof(MpegTSWrite, service_id), AV_OPT_TYPE_INT, {.i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
+      offsetof(MpegTSWrite, service_id), AV_OPT_TYPE_INT,
+      { .i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM },
     { "mpegts_pmt_start_pid", "Set the first pid of the PMT.",
-      offsetof(MpegTSWrite, pmt_start_pid), AV_OPT_TYPE_INT, {.i64 = 0x1000 }, 0x1000, 0x1f00, AV_OPT_FLAG_ENCODING_PARAM},
+      offsetof(MpegTSWrite, pmt_start_pid), AV_OPT_TYPE_INT,
+      { .i64 = 0x1000 }, 0x1000, 0x1f00, AV_OPT_FLAG_ENCODING_PARAM },
     { "mpegts_start_pid", "Set the first pid.",
-      offsetof(MpegTSWrite, start_pid), AV_OPT_TYPE_INT, {.i64 = 0x0100 }, 0x0100, 0x0f00, AV_OPT_FLAG_ENCODING_PARAM},
-    { "muxrate", NULL, offsetof(MpegTSWrite, mux_rate), AV_OPT_TYPE_INT, {.i64 = 1}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
+      offsetof(MpegTSWrite, start_pid), AV_OPT_TYPE_INT,
+      { .i64 = 0x0100 }, 0x0100, 0x0f00, AV_OPT_FLAG_ENCODING_PARAM },
+    { "muxrate", NULL,
+      offsetof(MpegTSWrite, mux_rate), AV_OPT_TYPE_INT,
+      { .i64 = 1 }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
     { "pes_payload_size", "Minimum PES packet payload in bytes",
-      offsetof(MpegTSWrite, pes_payload_size), AV_OPT_TYPE_INT, {.i64 = DEFAULT_PES_PAYLOAD_SIZE}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
-    { "mpegts_flags", "MPEG-TS muxing flags", offsetof(MpegTSWrite, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, INT_MAX,
+      offsetof(MpegTSWrite, pes_payload_size), AV_OPT_TYPE_INT,
+      { .i64 = DEFAULT_PES_PAYLOAD_SIZE }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
+    { "mpegts_flags", "MPEG-TS muxing flags",
+      offsetof(MpegTSWrite, flags), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, 0, INT_MAX,
       AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
     { "resend_headers", "Reemit PAT/PMT before writing the next packet",
-      0, AV_OPT_TYPE_CONST, {.i64 = MPEGTS_FLAG_REEMIT_PAT_PMT}, 0, INT_MAX,
-      AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags"},
+      0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_REEMIT_PAT_PMT }, 0, INT_MAX,
+      AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
     { "latm", "Use LATM packetization for AAC",
-      0, AV_OPT_TYPE_CONST, {.i64 = MPEGTS_FLAG_AAC_LATM}, 0, INT_MAX,
-      AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags"},
+      0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_AAC_LATM }, 0, INT_MAX,
+      AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
     // backward compatibility
     { "resend_headers", "Reemit PAT/PMT before writing the next packet",
-      offsetof(MpegTSWrite, reemit_pat_pmt), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
+      offsetof(MpegTSWrite, reemit_pat_pmt), AV_OPT_TYPE_INT,
+      { .i64 = 0 }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
     { "pcr_period", "PCR retransmission time",
-      offsetof(MpegTSWrite, pcr_period), AV_OPT_TYPE_INT, { .i64 = PCR_RETRANS_TIME }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
+      offsetof(MpegTSWrite, pcr_period), AV_OPT_TYPE_INT,
+      { .i64 = PCR_RETRANS_TIME }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
     { NULL },
 };