cinelerra-5.1/thirdparty/src/ffmpeg.git.patch2

   1 diff --git a/libavformat/mpegtsenc.c b/libavformat/mpegtsenc.c
   2 --- a/libavformat/mpegtsenc.c
   3 +++ b/libavformat/mpegtsenc.c
   4 @@ -56,7 +56,8 @@ typedef struct MpegTSService {
   5      int sid;           /* service ID */
   6      uint8_t name[256];
   7      uint8_t provider_name[256];
   8 -    int pcr_pid;
   9 +    int pcr_sid;       /* stream triggering pcr writes */
  10 +    int pcr_pid;       /* pid of pcr stream */
  11      AVProgram *program;
  12  } MpegTSService;
  13
  14 @@ -79,10 +80,8 @@ typedef struct MpegTSWrite {
  15      int64_t sdt_period; /* SDT period in PCR time base */
  16      int64_t pat_period; /* PAT/PMT period in PCR time base */
  17      int nb_services;
  18 -    int onid;
  19 -    int tsid;
  20 -    int64_t first_pcr;
  21 -    int64_t next_pcr;
  22 +    int onid, tsid;
  23 +    int64_t pcr, first_pcr, next_pcr, delay;
  24      int mux_rate; ///< set to 1 when VBR
  25      int pes_payload_size;
  26
  27 @@ -94,8 +93,8 @@ typedef struct MpegTSWrite {
  28      int pmt_start_pid;
  29      int start_pid;
  30      int m2ts_mode;
  31 +    int64_t ts_offset;
  32
  33 -    int pcr_period_ms;
  34  #define MPEGTS_FLAG_REEMIT_PAT_PMT  0x01
  35  #define MPEGTS_FLAG_AAC_LATM        0x02
  36  #define MPEGTS_FLAG_PAT_PMT_AT_FRAMES           0x04
  37 @@ -104,11 +103,11 @@ typedef struct MpegTSWrite {
  38      int flags;
  39      int copyts;
  40      int tables_version;
  41 -    int64_t pat_period_us;
  42 -    int64_t sdt_period_us;
  43 -    int64_t last_pat_ts;
  44 +    double pcr_period_ms;
  45 +    double sdt_period_ms;
  46 +    double pat_period_ms;
  47      int64_t last_sdt_ts;
  48 -
  49 +    int64_t last_pat_ts;
  50      int omit_video_pes_length;
  51  } MpegTSWrite;
  52
  53 @@ -217,10 +216,10 @@ static int mpegts_write_section1(MpegTSSection *s, int tid, int id,
  54  #define DEFAULT_PROVIDER_NAME   "FFmpeg"
  55  #define DEFAULT_SERVICE_NAME    "Service"
  56
  57 -/* we retransmit the SI info at this rate */
  58 +/* we retransmit the SI info at this rate (ms) */
  59  #define SDT_RETRANS_TIME 500
  60  #define PAT_RETRANS_TIME 100
  61 -#define PCR_RETRANS_TIME 20
  62 +#define PCR_RETRANS_TIME 50
  63
  64  typedef struct MpegTSWriteStream {
  65      int pid; /* stream associated pid */
  66 @@ -234,7 +233,7 @@ typedef struct MpegTSWriteStream {
  67      int payload_flags;
  68      uint8_t *payload;
  69      AVFormatContext *amux;
  70 -
  71 +    MpegTSService *service;
  72      int64_t pcr_period; /* PCR period in PCR time base */
  73      int64_t last_pcr;
  74
  75 @@ -713,18 +712,11 @@ invalid:
  76      return 0;
  77  }
  78
  79 -static int64_t get_pcr(const MpegTSWrite *ts, AVIOContext *pb)
  80 -{
  81 -    return av_rescale(avio_tell(pb) + 11, 8 * PCR_TIME_BASE, ts->mux_rate) +
  82 -           ts->first_pcr;
  83 -}
  84 -
  85  static void write_packet(AVFormatContext *s, const uint8_t *packet)
  86  {
  87      MpegTSWrite *ts = s->priv_data;
  88      if (ts->m2ts_mode) {
  89 -        int64_t pcr = get_pcr(s->priv_data, s->pb);
  90 -        uint32_t tp_extra_header = pcr % 0x3fffffff;
  91 +        uint32_t tp_extra_header = ts->pcr % 0x3fffffff;
  92          tp_extra_header = AV_RB32(&tp_extra_header);
  93          avio_write(s->pb, (unsigned char *) &tp_extra_header,
  94                     sizeof(tp_extra_header));
  95 @@ -763,6 +755,7 @@ static MpegTSService *mpegts_add_service(AVFormatContext *s, int sid,
  96      service->pmt.pid       = ts->pmt_start_pid + ts->nb_services;
  97      service->sid           = sid;
  98      service->pcr_pid       = 0x1fff;
  99 +    service->pcr_sid       = 0x1fff;
 100      if (encode_str8(service->provider_name, provider_name) < 0 ||
 101          encode_str8(service->name, service_name) < 0) {
 102          av_log(s, AV_LOG_ERROR, "Too long service or provider name\n");
 103 @@ -788,30 +781,32 @@ static void enable_pcr_generation_for_stream(AVFormatContext *s, AVStream *pcr_s
 104      MpegTSWrite *ts = s->priv_data;
 105      MpegTSWriteStream *ts_st = pcr_st->priv_data;
 106
 107 -    if (ts->mux_rate > 1 || ts->pcr_period_ms >= 0) {
 108 -        int pcr_period_ms = ts->pcr_period_ms == -1 ? PCR_RETRANS_TIME : ts->pcr_period_ms;
 109 -        ts_st->pcr_period = av_rescale(pcr_period_ms, PCR_TIME_BASE, 1000);
 110 -    } else {
 111 +    int64_t pcr_period = -1;
 112 +    if (ts->pcr_period_ms >= 0)
 113 +        pcr_period = av_rescale(ts->pcr_period_ms, PCR_TIME_BASE, 1000);
 114 +    else if (ts->mux_rate == 1) {
 115          /* By default, for VBR we select the highest multiple of frame duration which is less than 100 ms. */
 116          int64_t frame_period = 0;
 117          if (pcr_st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
 118              int frame_size = av_get_audio_frame_duration2(pcr_st->codecpar, 0);
 119 -            if (!frame_size) {
 120 +            if (frame_size > 0)
 121 +               frame_period = av_rescale_rnd(frame_size, PCR_TIME_BASE, pcr_st->codecpar->sample_rate, AV_ROUND_UP);
 122 +            else
 123                 av_log(s, AV_LOG_WARNING, "frame size not set\n");
 124 -               frame_size = 512;
 125 -            }
 126 -            frame_period = av_rescale_rnd(frame_size, PCR_TIME_BASE, pcr_st->codecpar->sample_rate, AV_ROUND_UP);
 127          } else if (pcr_st->avg_frame_rate.num) {
 128              frame_period = av_rescale_rnd(pcr_st->avg_frame_rate.den, PCR_TIME_BASE, pcr_st->avg_frame_rate.num, AV_ROUND_UP);
 129          }
 130 -        if (frame_period > 0 && frame_period <= PCR_TIME_BASE / 10)
 131 -            ts_st->pcr_period = frame_period * (PCR_TIME_BASE / 10 / frame_period);
 132 -        else
 133 -            ts_st->pcr_period = 1;
 134 +        if (frame_period > 0 && frame_period <= PCR_TIME_BASE / 10) {
 135 +            int pcr_frames = (PCR_TIME_BASE / 10) / frame_period;
 136 +            if( pcr_frames > 0 )
 137 +                pcr_period = frame_period * pcr_frames;
 138 +        }
 139      }
 140 -
 141 +    if( pcr_period < 0 )
 142 +       pcr_period = av_rescale(PCR_RETRANS_TIME, PCR_TIME_BASE, 1000);
 143 +    ts_st->pcr_period = pcr_period;
 144      // output a PCR as soon as possible
 145 -    ts_st->last_pcr   = ts->first_pcr - ts_st->pcr_period;
 146 +    ts_st->last_pcr   = ts->first_pcr - pcr_period;
 147  }
 148
 149  static void select_pcr_streams(AVFormatContext *s)
 150 @@ -823,22 +818,32 @@ static void select_pcr_streams(AVFormatContext *s)
 151          AVStream *pcr_st = NULL;
 152          AVProgram *program = service->program;
 153          int nb_streams = program ? program->nb_stream_indexes : s->nb_streams;
 154 -
 155 +        /* find first video stream, or just use first stream */
 156          for (int j = 0; j < nb_streams; j++) {
 157              AVStream *st = s->streams[program ? program->stream_index[j] : j];
 158 -            if (!pcr_st ||
 159 -                pcr_st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO && st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
 160 -            {
 161 +            if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
 162                  pcr_st = st;
 163 +                break;
 164              }
 165          }
 166 -
 167 +        if (!pcr_st && s->nb_streams > 0)
 168 +            pcr_st = s->streams[0];
 169          if (pcr_st) {
 170              MpegTSWriteStream *ts_st = pcr_st->priv_data;
 171 -            service->pcr_pid = ts_st->pid;
 172 +            service->pcr_sid = ts_st->pid;  /* stream id for pcr writes */
 173 +            service->pcr_pid = ts->m2ts_mode > 1 ? /* pcr pid */
 174 +               0x1000 + ts->service_id : ts_st->pid;
 175              enable_pcr_generation_for_stream(s, pcr_st);
 176              av_log(s, AV_LOG_VERBOSE, "service %i using PCR in pid=%i, pcr_period=%"PRId64"ms\n",
 177                  service->sid, service->pcr_pid, av_rescale(ts_st->pcr_period, 1000, PCR_TIME_BASE));
 178 +            for (int j = 0; j < nb_streams; j++) {
 179 +                AVStream *st = s->streams[program ? program->stream_index[j] : j];
 180 +                MpegTSWriteStream *ts_st = st->priv_data;
 181 +                ts_st->service = service;
 182 +            }
 183 +            if (service->pmt.pid == service->pcr_pid) {
 184 +                av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", service->pcr_pid);
 185 +            }
 186          }
 187      }
 188  }
 189 @@ -860,6 +865,15 @@ static int mpegts_init(AVFormatContext *s)
 190
 191      if (s->max_delay < 0) /* Not set by the caller */
 192          s->max_delay = 0;
 193 +    ts->delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE);
 194 +
 195 +    if (ts->m2ts_mode == -1) {
 196 +        if (av_match_ext(s->url, "m2ts")) {
 197 +            ts->m2ts_mode = 1;
 198 +        } else {
 199 +            ts->m2ts_mode = 0;
 200 +        }
 201 +    }
 202
 203      // round up to a whole number of TS packets
 204      ts->pes_payload_size = (ts->pes_payload_size + 14 + 183) / 184 * 184 - 14;
 205 @@ -920,14 +934,11 @@ static int mpegts_init(AVFormatContext *s)
 206
 207          /* MPEG pid values < 16 are reserved. Applications which set st->id in
 208           * this range are assigned a calculated pid. */
 209 -        if (st->id < 16) {
 210 -            ts_st->pid = ts->start_pid + i;
 211 -        } else {
 212 -            ts_st->pid = st->id;
 213 -        }
 214 -        if (ts_st->pid >= 0x1FFF) {
 215 +        ts_st->pid = ts->start_pid >= 0 ?  ts->start_pid + i :
 216 +            st->id >= 16 ? st->id : FIRST_OTHER_PID + i;
 217 +        if (ts_st->pid < 16 || ts_st->pid >= 0x1FFF) {
 218              av_log(s, AV_LOG_ERROR,
 219 -                   "Invalid stream id %d, must be less than 8191\n", st->id);
 220 +                   "Invalid stream id %d, must be in 16...8191\n", ts_st->pid);
 221              ret = AVERROR(EINVAL);
 222              goto fail;
 223          }
 224 @@ -998,8 +1009,8 @@ static int mpegts_init(AVFormatContext *s)
 225
 226      ts->last_pat_ts = AV_NOPTS_VALUE;
 227      ts->last_sdt_ts = AV_NOPTS_VALUE;
 228 -    ts->pat_period = av_rescale(ts->pat_period_us, PCR_TIME_BASE, AV_TIME_BASE);
 229 -    ts->sdt_period = av_rescale(ts->sdt_period_us, PCR_TIME_BASE, AV_TIME_BASE);
 230 +    ts->pat_period = av_rescale(ts->pat_period_ms, PCR_TIME_BASE, 1000);
 231 +    ts->sdt_period = av_rescale(ts->sdt_period_ms, PCR_TIME_BASE, 1000);
 232
 233      if (ts->mux_rate == 1)
 234          av_log(s, AV_LOG_VERBOSE, "muxrate VBR, ");
 235 @@ -1022,20 +1033,16 @@ static void retransmit_si_info(AVFormatContext *s, int force_pat, int force_sdt,
 236  {
 237      MpegTSWrite *ts = s->priv_data;
 238      int i;
 239 -
 240 -    if ((pcr != AV_NOPTS_VALUE && ts->last_sdt_ts == AV_NOPTS_VALUE) ||
 241 -        (pcr != AV_NOPTS_VALUE && pcr - ts->last_sdt_ts >= ts->sdt_period) ||
 242 -        force_sdt
 243 -    ) {
 244 -        if (pcr != AV_NOPTS_VALUE)
 245 -            ts->last_sdt_ts = FFMAX(pcr, ts->last_sdt_ts);
 246 +    if (force_sdt || (ts->sdt_period >= 0 && pcr != AV_NOPTS_VALUE &&
 247 +         (ts->last_sdt_ts == AV_NOPTS_VALUE || (pcr - ts->last_sdt_ts >= ts->sdt_period)) )) {
 248 +        if (pcr > ts->last_sdt_ts)
 249 +            ts->last_sdt_ts = pcr;
 250          mpegts_write_sdt(s);
 251      }
 252 -    if ((pcr != AV_NOPTS_VALUE && ts->last_pat_ts == AV_NOPTS_VALUE) ||
 253 -        (pcr != AV_NOPTS_VALUE && pcr - ts->last_pat_ts >= ts->pat_period) ||
 254 -        force_pat) {
 255 -        if (pcr != AV_NOPTS_VALUE)
 256 -            ts->last_pat_ts = FFMAX(pcr, ts->last_pat_ts);
 257 +    if (force_pat || (ts->pat_period >= 0 && pcr != AV_NOPTS_VALUE &&
 258 +         (ts->last_pat_ts == AV_NOPTS_VALUE || (pcr - ts->last_pat_ts >= ts->pat_period)) )) {
 259 +        if (pcr > ts->last_pat_ts)
 260 +            ts->last_pat_ts = pcr;
 261          mpegts_write_pat(s);
 262          for (i = 0; i < ts->nb_services; i++)
 263              mpegts_write_pmt(s, ts->services[i]);
 264 @@ -1076,13 +1083,14 @@ static void mpegts_insert_pcr_only(AVFormatContext *s, AVStream *st)
 265  {
 266      MpegTSWrite *ts = s->priv_data;
 267      MpegTSWriteStream *ts_st = st->priv_data;
 268 +    uint32_t pcr_pid = ts_st->service->pcr_pid;
 269      uint8_t *q;
 270      uint8_t buf[TS_PACKET_SIZE];
 271
 272      q    = buf;
 273      *q++ = 0x47;
 274 -    *q++ = ts_st->pid >> 8;
 275 -    *q++ = ts_st->pid;
 276 +    *q++ = pcr_pid >> 8;
 277 +    *q++ = pcr_pid;
 278      *q++ = 0x20 | ts_st->cc;   /* Adaptation only */
 279      /* Continuity Count field does not increment (see 13818-1 section 2.4.3.3) */
 280      *q++ = TS_PACKET_SIZE - 5; /* Adaptation Field Length */
 281 @@ -1093,7 +1101,7 @@ static void mpegts_insert_pcr_only(AVFormatContext *s, AVStream *st)
 282      }
 283
 284      /* PCR coded into 6 bytes */
 285 -    q += write_pcr_bits(q, get_pcr(ts, s->pb));
 286 +    q += write_pcr_bits(q, ts->pcr);
 287
 288      /* stuffing bytes */
 289      memset(q, 0xFF, TS_PACKET_SIZE - (q - buf));
 290 @@ -1161,7 +1169,6 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
 291      uint8_t *q;
 292      int val, is_start, len, header_len, write_pcr, is_dvb_subtitle, is_dvb_teletext, flags;
 293      int afc_len, stuffing_len;
 294 -    int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE);
 295      int force_pat = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && key && !ts_st->prev_payload_key;
 296      int force_sdt = 0;
 297
 298 @@ -1178,67 +1185,46 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
 299
 300      is_start = 1;
 301      while (payload_size > 0) {
 302 -        int64_t pcr = AV_NOPTS_VALUE;
 303 -        if (ts->mux_rate > 1)
 304 -            pcr = get_pcr(ts, s->pb);
 305 -        else if (dts != AV_NOPTS_VALUE)
 306 -            pcr = (dts - delay) * 300;
 307 +        ts->pcr = ts->first_pcr + (ts->mux_rate == 1 ?
 308 +            (dts == AV_NOPTS_VALUE ? 0 : (dts - ts->delay) * 300) :
 309 +            // add 11, pcr references the last byte of program clock reference base
 310 +            av_rescale(avio_tell(s->pb) + 11, 8 * PCR_TIME_BASE, ts->mux_rate));
 311
 312 -        retransmit_si_info(s, force_pat, force_sdt, pcr);
 313 +        retransmit_si_info(s, force_pat, force_sdt, ts->pcr);
 314          force_pat = 0;
 315          force_sdt = 0;
 316
 317          write_pcr = 0;
 318 -        if (ts->mux_rate > 1) {
 319 -            /* Send PCR packets for all PCR streams if needed */
 320 -            pcr = get_pcr(ts, s->pb);
 321 -            if (pcr >= ts->next_pcr) {
 322 -                int64_t next_pcr = INT64_MAX;
 323 -                for (int i = 0; i < s->nb_streams; i++) {
 324 -                    /* Make the current stream the last, because for that we
 325 -                     * can insert the pcr into the payload later */
 326 -                    int st2_index = i < st->index ? i : (i + 1 == s->nb_streams ? st->index : i + 1);
 327 -                    AVStream *st2 = s->streams[st2_index];
 328 -                    MpegTSWriteStream *ts_st2 = st2->priv_data;
 329 -                    if (ts_st2->pcr_period) {
 330 -                        if (pcr - ts_st2->last_pcr >= ts_st2->pcr_period) {
 331 -                            ts_st2->last_pcr = FFMAX(pcr - ts_st2->pcr_period, ts_st2->last_pcr + ts_st2->pcr_period);
 332 -                            if (st2 != st) {
 333 -                                mpegts_insert_pcr_only(s, st2);
 334 -                                pcr = get_pcr(ts, s->pb);
 335 -                            } else {
 336 -                                write_pcr = 1;
 337 -                            }
 338 -                        }
 339 -                        next_pcr = FFMIN(next_pcr, ts_st2->last_pcr + ts_st2->pcr_period);
 340 -                    }
 341 -                }
 342 -                ts->next_pcr = next_pcr;
 343 -            }
 344 -            if (dts != AV_NOPTS_VALUE && (dts - pcr / 300) > delay) {
 345 -                /* pcr insert gets priority over null packet insert */
 346 -                if (write_pcr)
 347 -                    mpegts_insert_pcr_only(s, st);
 348 -                else
 349 -                    mpegts_insert_null_packet(s);
 350 -                /* recalculate write_pcr and possibly retransmit si_info */
 351 -                continue;
 352 -            }
 353 -        } else if (ts_st->pcr_period && pcr != AV_NOPTS_VALUE) {
 354 -            if (pcr - ts_st->last_pcr >= ts_st->pcr_period && is_start) {
 355 -                ts_st->last_pcr = FFMAX(pcr - ts_st->pcr_period, ts_st->last_pcr + ts_st->pcr_period);
 356 -                write_pcr = 1;
 357 -            }
 358 +        if (ts_st->pcr_period > 0 && ts_st->pid == ts_st->service->pcr_sid &&
 359 +            ts->pcr - ts_st->last_pcr >= ts_st->pcr_period) {
 360 +            ts_st->last_pcr = ts->pcr;
 361 +            write_pcr = 1;
 362 +        }
 363 +        if (write_pcr && ts_st->service->pcr_sid != ts_st->service->pcr_pid) {
 364 +            /* pcr is on a seperate stream */
 365 +            mpegts_insert_pcr_only(s, st);
 366 +            continue;
 367 +        }
 368 +
 369 +        if (ts->mux_rate > 1 && dts != AV_NOPTS_VALUE &&
 370 +               (dts - ts->pcr / 300) > ts->delay) {
 371 +            /* pcr insert gets priority over null packet insert */
 372 +            if (write_pcr)
 373 +                mpegts_insert_pcr_only(s, st);
 374 +            else
 375 +                mpegts_insert_null_packet(s);
 376 +            /* recalculate write_pcr and possibly retransimit si_info */
 377 +            continue;
 378          }
 379
 380          /* prepare packet header */
 381          q    = buf;
 382          *q++ = 0x47;
 383          val  = ts_st->pid >> 8;
 384 -        if (ts->m2ts_mode && st->codecpar->codec_id == AV_CODEC_ID_AC3)
 385 -            val |= 0x20;
 386          if (is_start)
 387              val |= 0x40;
 388 +        if (ts->m2ts_mode && st->codecpar->codec_id == AV_CODEC_ID_AC3)
 389 +            val |= 0x20;
 390          *q++      = val;
 391          *q++      = ts_st->pid;
 392          ts_st->cc = ts_st->cc + 1 & 0xf;
 393 @@ -1250,7 +1236,7 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
 394          }
 395          if (key && is_start && pts != AV_NOPTS_VALUE) {
 396              // set Random Access for key frames
 397 -            if (ts_st->pcr_period)
 398 +            if ( ts_st->pcr_period > 0 && ts_st->pid == ts_st->service->pcr_sid )
 399                  write_pcr = 1;
 400              set_af_flag(buf, 0x40);
 401              q = get_ts_payload_start(buf);
 402 @@ -1258,10 +1244,9 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
 403          if (write_pcr) {
 404              set_af_flag(buf, 0x10);
 405              q = get_ts_payload_start(buf);
 406 -            // add 11, pcr references the last byte of program clock reference base
 407 -            if (dts != AV_NOPTS_VALUE && dts < pcr / 300)
 408 +            if (dts != AV_NOPTS_VALUE && dts < ts->pcr / 300)
 409                  av_log(s, AV_LOG_WARNING, "dts < pcr, TS is invalid\n");
 410 -            extend_af(buf, write_pcr_bits(q, pcr));
 411 +            extend_af(buf, write_pcr_bits(q, ts->pcr));
 412              q = get_ts_payload_start(buf);
 413          }
 414          if (is_start) {
 415 @@ -1362,11 +1347,13 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
 416              *q++ = flags;
 417              *q++ = header_len;
 418              if (pts != AV_NOPTS_VALUE) {
 419 -                write_pts(q, flags >> 6, pts);
 420 +                int64_t ts_pts = pts + ts->ts_offset;
 421 +                write_pts(q, flags >> 6, ts_pts);
 422                  q += 5;
 423              }
 424              if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
 425 -                write_pts(q, 1, dts);
 426 +                int64_t ts_dts = dts + ts->ts_offset;
 427 +                write_pts(q, 1, ts_dts);
 428                  q += 5;
 429              }
 430              if (pes_extension && st->codecpar->codec_id == AV_CODEC_ID_DIRAC) {
 431 @@ -1536,7 +1523,6 @@ static int mpegts_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
 432      uint8_t *data = NULL;
 433      MpegTSWrite *ts = s->priv_data;
 434      MpegTSWriteStream *ts_st = st->priv_data;
 435 -    const int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE) * 2;
 436      const int64_t max_audio_delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE) / 2;
 437      int64_t dts = pkt->dts, pts = pkt->pts;
 438      int opus_samples = 0;
 439 @@ -1552,9 +1538,9 @@ static int mpegts_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
 440
 441      if (ts->copyts < 1) {
 442          if (pts != AV_NOPTS_VALUE)
 443 -            pts += delay;
 444 +            pts += ts->delay * 2;
 445          if (dts != AV_NOPTS_VALUE)
 446 -            dts += delay;
 447 +            dts += ts->delay * 2;
 448      }
 449
 450      if (ts_st->first_pts_check && pts == AV_NOPTS_VALUE) {
 451 @@ -1904,10 +1890,13 @@ static const AVOption options[] = {
 452        { .i64 = 0x1000 }, FIRST_OTHER_PID, LAST_OTHER_PID, AV_OPT_FLAG_ENCODING_PARAM },
 453      { "mpegts_start_pid", "Set the first pid.",
 454        offsetof(MpegTSWrite, start_pid), AV_OPT_TYPE_INT,
 455 -      { .i64 = 0x0100 }, FIRST_OTHER_PID, LAST_OTHER_PID, AV_OPT_FLAG_ENCODING_PARAM },
 456 +      { .i64 = -1 }, -1, LAST_OTHER_PID, AV_OPT_FLAG_ENCODING_PARAM },
 457      { "mpegts_m2ts_mode", "Enable m2ts mode.",
 458 -      offsetof(MpegTSWrite, m2ts_mode), AV_OPT_TYPE_BOOL,
 459 -      { .i64 = -1 }, -1, 1, AV_OPT_FLAG_ENCODING_PARAM },
 460 +      offsetof(MpegTSWrite, m2ts_mode), AV_OPT_TYPE_INT,
 461 +      { .i64 = -1 }, -1, 2, AV_OPT_FLAG_ENCODING_PARAM },
 462 +    { "mpegts_pcr_offset", "clock offset.",
 463 +      offsetof(MpegTSWrite, ts_offset), AV_OPT_TYPE_BOOL,
 464 +      { .i64 = 0 }, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
 465      { "muxrate", NULL,
 466        offsetof(MpegTSWrite, mux_rate), AV_OPT_TYPE_INT,
 467        { .i64 = 1 }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
 468 @@ -1941,15 +1930,15 @@ static const AVOption options[] = {
 469      { "omit_video_pes_length", "Omit the PES packet length for video packets",
 470        offsetof(MpegTSWrite, omit_video_pes_length), AV_OPT_TYPE_BOOL,
 471        { .i64 = 1 }, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
 472 -    { "pcr_period", "PCR retransmission time in milliseconds",
 473 -      offsetof(MpegTSWrite, pcr_period_ms), AV_OPT_TYPE_INT,
 474 -      { .i64 = -1 }, -1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
 475 -    { "pat_period", "PAT/PMT retransmission time limit in seconds",
 476 -      offsetof(MpegTSWrite, pat_period_us), AV_OPT_TYPE_DURATION,
 477 -      { .i64 = PAT_RETRANS_TIME * 1000LL }, 0, INT64_MAX, AV_OPT_FLAG_ENCODING_PARAM },
 478 -    { "sdt_period", "SDT retransmission time limit in seconds",
 479 -      offsetof(MpegTSWrite, sdt_period_us), AV_OPT_TYPE_DURATION,
 480 -      { .i64 = SDT_RETRANS_TIME * 1000LL }, 0, INT64_MAX, AV_OPT_FLAG_ENCODING_PARAM },
 481 +    { "pcr_period", "PCR retransmission time limit in msecs",
 482 +      offsetof(MpegTSWrite, pcr_period_ms), AV_OPT_TYPE_DOUBLE,
 483 +      { .dbl = -1 }, -1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
 484 +    { "pat_period", "PAT/PMT retransmission time limit in msecs",
 485 +      offsetof(MpegTSWrite, pat_period_ms), AV_OPT_TYPE_DOUBLE,
 486 +      { .dbl = PAT_RETRANS_TIME }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
 487 +    { "sdt_period", "SDT retransmission time limit in msecs",
 488 +      offsetof(MpegTSWrite, sdt_period_ms), AV_OPT_TYPE_DOUBLE,
 489 +      { .dbl = SDT_RETRANS_TIME }, -1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
 490      { NULL },
 491  };
 492