Merge commit '9d64f236292ba28018dd9afd2d57f8f944b33f81'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 29 Jul 2013 12:18:37 +0000 (14:18 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 29 Jul 2013 12:18:37 +0000 (14:18 +0200)
* commit '9d64f236292ba28018dd9afd2d57f8f944b33f81':
  hls: Respect the different stream time bases when comparing dts

Conflicts:
libavformat/hls.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavformat/hls.c

diff --combined libavformat/hls.c
@@@ -2,20 -2,20 +2,20 @@@
   * Apple HTTP Live Streaming demuxer
   * Copyright (c) 2010 Martin Storsjo
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -56,7 -56,7 +56,7 @@@ enum KeyType 
  };
  
  struct segment {
 -    int duration;
 +    double duration;
      char url[MAX_URL_SIZE];
      char key[MAX_URL_SIZE];
      enum KeyType key_type;
@@@ -103,8 -103,6 +103,8 @@@ typedef struct HLSContext 
      int64_t seek_timestamp;
      int seek_flags;
      AVIOInterruptCB *interrupt_callback;
 +    char *user_agent;                    ///< holds HTTP user agent set as an AVOption to the HTTP protocol context
 +    char *cookies;                       ///< holds HTTP cookie values set in either the initial response or as an AVOption to the HTTP protocol context
  } HLSContext;
  
  static int read_chomp_line(AVIOContext *s, char *buf, int maxlen)
@@@ -141,8 -139,6 +141,8 @@@ static void free_variant_list(HLSContex
          av_free(var);
      }
      av_freep(&c->variants);
 +    av_freep(&c->cookies);
 +    av_freep(&c->user_agent);
      c->n_variants = 0;
  }
  
@@@ -206,8 -202,7 +206,8 @@@ static void handle_key_args(struct key_
  static int parse_playlist(HLSContext *c, const char *url,
                            struct variant *var, AVIOContext *in)
  {
 -    int ret = 0, duration = 0, is_segment = 0, is_variant = 0, bandwidth = 0;
 +    int ret = 0, is_segment = 0, is_variant = 0, bandwidth = 0;
 +    double duration = 0.0;
      enum KeyType key_type = KEY_NONE;
      uint8_t iv[16] = "";
      int has_iv = 0;
      int close_in = 0;
  
      if (!in) {
 +        AVDictionary *opts = NULL;
          close_in = 1;
 -        if ((ret = avio_open2(&in, url, AVIO_FLAG_READ,
 -                              c->interrupt_callback, NULL)) < 0)
 +        /* Some HLS servers don't like being sent the range header */
 +        av_dict_set(&opts, "seekable", "0", 0);
 +
 +        // broker prior HTTP options that should be consistent across requests
 +        av_dict_set(&opts, "user-agent", c->user_agent, 0);
 +        av_dict_set(&opts, "cookies", c->cookies, 0);
 +
 +        ret = avio_open2(&in, url, AVIO_FLAG_READ,
 +                         c->interrupt_callback, &opts);
 +        av_dict_free(&opts);
 +        if (ret < 0)
              return ret;
      }
  
          free_segment_list(var);
          var->finished = 0;
      }
 -    while (!in->eof_reached) {
 +    while (!url_feof(in)) {
          read_chomp_line(in, line, sizeof(line));
          if (av_strstart(line, "#EXT-X-STREAM-INF:", &ptr)) {
              struct variant_info info = {{0}};
                  var->finished = 1;
          } else if (av_strstart(line, "#EXTINF:", &ptr)) {
              is_segment = 1;
 -            duration   = atoi(ptr);
 +            duration   = atof(ptr);
          } else if (av_strstart(line, "#", NULL)) {
              continue;
          } else if (line[0]) {
@@@ -338,27 -323,19 +338,27 @@@ fail
      return ret;
  }
  
 -static int open_input(struct variant *var)
 +static int open_input(HLSContext *c, struct variant *var)
  {
 +    AVDictionary *opts = NULL;
 +    int ret;
      struct segment *seg = var->segments[var->cur_seq_no - var->start_seq_no];
 +
 +    // broker prior HTTP options that should be consistent across requests
 +    av_dict_set(&opts, "user-agent", c->user_agent, 0);
 +    av_dict_set(&opts, "cookies", c->cookies, 0);
 +    av_dict_set(&opts, "seekable", "0", 0);
 +
      if (seg->key_type == KEY_NONE) {
 -        return ffurl_open(&var->input, seg->url, AVIO_FLAG_READ,
 -                          &var->parent->interrupt_callback, NULL);
 +        ret = ffurl_open(&var->input, seg->url, AVIO_FLAG_READ,
 +                          &var->parent->interrupt_callback, &opts);
 +        goto cleanup;
      } else if (seg->key_type == KEY_AES_128) {
          char iv[33], key[33], url[MAX_URL_SIZE];
 -        int ret;
          if (strcmp(seg->key, var->key_url)) {
              URLContext *uc;
              if (ffurl_open(&uc, seg->key, AVIO_FLAG_READ,
 -                           &var->parent->interrupt_callback, NULL) == 0) {
 +                           &var->parent->interrupt_callback, &opts) == 0) {
                  if (ffurl_read_complete(uc, var->key, sizeof(var->key))
                      != sizeof(var->key)) {
                      av_log(NULL, AV_LOG_ERROR, "Unable to read key file %s\n",
              snprintf(url, sizeof(url), "crypto:%s", seg->url);
          if ((ret = ffurl_alloc(&var->input, url, AVIO_FLAG_READ,
                                 &var->parent->interrupt_callback)) < 0)
 -            return ret;
 +            goto cleanup;
          av_opt_set(var->input->priv_data, "key", key, 0);
          av_opt_set(var->input->priv_data, "iv", iv, 0);
 -        if ((ret = ffurl_connect(var->input, NULL)) < 0) {
 +        /* Need to repopulate options */
 +        av_dict_free(&opts);
 +        av_dict_set(&opts, "seekable", "0", 0);
 +        if ((ret = ffurl_connect(var->input, &opts)) < 0) {
              ffurl_close(var->input);
              var->input = NULL;
 -            return ret;
 +            goto cleanup;
          }
 -        return 0;
 +        ret = 0;
      }
 -    return AVERROR(ENOSYS);
 +    else
 +      ret = AVERROR(ENOSYS);
 +
 +cleanup:
 +    av_dict_free(&opts);
 +    return ret;
  }
  
  static int read_data(void *opaque, uint8_t *buf, int buf_size)
@@@ -424,7 -393,7 +424,7 @@@ reload
              /* If we need to reload the playlist again below (if
               * there's still no more segments), switch to a reload
               * interval of half the target duration. */
 -            reload_interval = v->target_duration * 500000;
 +            reload_interval = v->target_duration * 500000LL;
          }
          if (v->cur_seq_no < v->start_seq_no) {
              av_log(NULL, AV_LOG_WARNING,
              goto reload;
          }
  
 -        ret = open_input(v);
 +        ret = open_input(c, v);
          if (ret < 0)
              return ret;
      }
  
  static int hls_read_header(AVFormatContext *s)
  {
 +    URLContext *u = (s->flags & AVFMT_FLAG_CUSTOM_IO) ? NULL : s->pb->opaque;
      HLSContext *c = s->priv_data;
      int ret = 0, i, j, stream_offset = 0;
  
      c->interrupt_callback = &s->interrupt_callback;
  
 +    // if the URL context is good, read important options we must broker later
 +    if (u && u->prot->priv_data_class) {
 +        // get the previous user agent & set back to null if string size is zero
 +        av_freep(&c->user_agent);
 +        av_opt_get(u->priv_data, "user-agent", 0, (uint8_t**)&(c->user_agent));
 +        if (c->user_agent && !strlen(c->user_agent))
 +            av_freep(&c->user_agent);
 +
 +        // get the previous cookies & set back to null if string size is zero
 +        av_freep(&c->cookies);
 +        av_opt_get(u->priv_data, "cookies", 0, (uint8_t**)&(c->cookies));
 +        if (c->cookies && !strlen(c->cookies))
 +            av_freep(&c->cookies);
 +    }
 +
      if ((ret = parse_playlist(c, s->filename, NULL, s->pb)) < 0)
          goto fail;
  
      if (c->variants[0]->finished) {
          int64_t duration = 0;
          for (i = 0; i < c->variants[0]->n_segments; i++)
 -            duration += c->variants[0]->segments[i]->duration;
 -        s->duration = duration * AV_TIME_BASE;
 +            duration += round(c->variants[0]->segments[i]->duration * AV_TIME_BASE);
 +        s->duration = duration;
      }
  
      /* Open the demuxer for each variant */
          struct variant *v = c->variants[i];
          AVInputFormat *in_fmt = NULL;
          char bitrate_str[20];
 +        AVProgram *program = NULL;
          if (v->n_segments == 0)
              continue;
  
               * so avformat_close_input shouldn't be called. If
               * avformat_open_input fails below, it frees and zeros the
               * context, so it doesn't need any special treatment like this. */
 +            av_log(s, AV_LOG_ERROR, "Error when loading first segment '%s'\n", v->segments[0]->url);
              avformat_free_context(v->ctx);
              v->ctx = NULL;
              goto fail;
          v->ctx->pb       = &v->pb;
          v->stream_offset = stream_offset;
          ret = avformat_open_input(&v->ctx, v->segments[0]->url, in_fmt, NULL);
 +        if (ret < 0)
 +            goto fail;
 +        v->ctx->ctx_flags &= ~AVFMTCTX_NOHEADER;
 +        ret = avformat_find_stream_info(v->ctx, NULL);
          if (ret < 0)
              goto fail;
          snprintf(bitrate_str, sizeof(bitrate_str), "%d", v->bandwidth);
 +
 +        /* Create new AVprogram for variant i */
 +        program = av_new_program(s, i);
 +        if (!program)
 +            goto fail;
 +        av_dict_set(&program->metadata, "variant_bitrate", bitrate_str, 0);
 +
          /* Create new AVStreams for each stream in this variant */
          for (j = 0; j < v->ctx->nb_streams; j++) {
              AVStream *st = avformat_new_stream(s, NULL);
                  ret = AVERROR(ENOMEM);
                  goto fail;
              }
 +            ff_program_add_stream_index(s, i, stream_offset + j);
              st->id = i;
              avpriv_set_pts_info(st, ist->pts_wrap_bits, ist->time_base.num, ist->time_base.den);
              avcodec_copy_context(st->codec, v->ctx->streams[j]->codec);
@@@ -624,7 -563,7 +624,7 @@@ static int recheck_discard_flags(AVForm
  
      /* Check if any new streams are needed */
      for (i = 0; i < c->n_variants; i++)
 -        c->variants[i]->cur_needed = 0;;
 +        c->variants[i]->cur_needed = 0;
  
      for (i = 0; i < s->nb_streams; i++) {
          AVStream *st = s->streams[i];
@@@ -674,7 -613,7 +674,7 @@@ start
                  AVStream *st;
                  ret = av_read_frame(var->ctx, &var->pkt);
                  if (ret < 0) {
 -                    if (!var->pb.eof_reached)
 +                    if (!url_feof(&var->pb) && ret != AVERROR_EOF)
                          return ret;
                      reset_packet(&var->pkt);
                      break;
          /* Check if this stream still is on an earlier segment number, or
           * has the packet with the lowest dts */
          if (var->pkt.data) {
-             if (minvariant < 0 ||
-                 var->cur_seq_no < c->variants[minvariant]->cur_seq_no) {
+             struct variant *minvar = c->variants[minvariant];
+             if (minvariant < 0 || var->cur_seq_no < minvar->cur_seq_no) {
                  minvariant = i;
-             } else if (var->cur_seq_no == c->variants[minvariant]->cur_seq_no) {
-                 struct variant *minvar = c->variants[minvariant];
-                 int64_t dts    =    var->pkt.dts;
-                 int64_t mindts = minvar->pkt.dts;
-                 AVStream *st   =    var->ctx->streams[   var->pkt.stream_index];
-                 AVStream *minst= minvar->ctx->streams[minvar->pkt.stream_index];
+             } else if (var->cur_seq_no == minvar->cur_seq_no) {
+                 int64_t dts     =    var->pkt.dts;
+                 int64_t mindts  = minvar->pkt.dts;
+                 AVStream *st    =    var->ctx->streams[var->pkt.stream_index];
+                 AVStream *minst = minvar->ctx->streams[minvar->pkt.stream_index];
  
-                 if(   st->start_time != AV_NOPTS_VALUE)    dts -=    st->start_time;
-                 if(minst->start_time != AV_NOPTS_VALUE) mindts -= minst->start_time;
-                 if (av_compare_ts(dts, st->time_base, mindts, minst->time_base) < 0)
+                 if (dts == AV_NOPTS_VALUE) {
                      minvariant = i;
+                 } else if (mindts != AV_NOPTS_VALUE) {
+                     if (st->start_time    != AV_NOPTS_VALUE)
+                         dts    -= st->start_time;
+                     if (minst->start_time != AV_NOPTS_VALUE)
+                         mindts -= minst->start_time;
+                     if (av_compare_ts(dts, st->time_base,
+                                       mindts, minst->time_base) < 0)
+                         minvariant = i;
+                 }
              }
          }
      }
@@@ -774,11 -719,10 +780,11 @@@ static int hls_read_seek(AVFormatContex
          /* Reset reading */
          struct variant *var = c->variants[i];
          int64_t pos = c->first_timestamp == AV_NOPTS_VALUE ? 0 :
 -                      av_rescale_rnd(c->first_timestamp, 1,
 -                          stream_index >= 0 ? s->streams[stream_index]->time_base.den : AV_TIME_BASE,
 -                          flags & AVSEEK_FLAG_BACKWARD ? AV_ROUND_DOWN : AV_ROUND_UP);
 -        if (var->input) {
 +                      av_rescale_rnd(c->first_timestamp, 1, stream_index >= 0 ?
 +                               s->streams[stream_index]->time_base.den :
 +                               AV_TIME_BASE, flags & AVSEEK_FLAG_BACKWARD ?
 +                               AV_ROUND_DOWN : AV_ROUND_UP);
 +         if (var->input) {
              ffurl_close(var->input);
              var->input = NULL;
          }