Merge commit '8747926'
authorMichael Niedermayer <michaelni@gmx.at>
Thu, 6 Nov 2014 09:50:59 +0000 (10:50 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Thu, 6 Nov 2014 09:50:59 +0000 (10:50 +0100)
* commit '8747926':
  vorbis_parser: use a dedicated AVClass for logging

Conflicts:
libavcodec/vorbis_parser.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/vorbis_parser.c
libavcodec/vorbis_parser.h

@@@ -1,20 -1,20 +1,20 @@@
  /*
   * Copyright (c) 2012 Justin Ruggles
   *
 - * 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
   */
  
   * Determines the duration for each packet.
   */
  
+ #include "libavutil/log.h"
  #include "get_bits.h"
  #include "parser.h"
  #include "xiph.h"
  #include "vorbis_parser.h"
  
- static int parse_id_header(AVCodecContext *avctx, VorbisParseContext *s,
+ static const AVClass vorbis_parser_class = {
+     .class_name = "Vorbis parser",
+     .item_name  = av_default_item_name,
+     .version    = LIBAVUTIL_VERSION_INT,
+ };
+ static int parse_id_header(VorbisParseContext *s,
                             const uint8_t *buf, int buf_size)
  {
      /* Id header should be 30 bytes */
      if (buf_size < 30) {
-         av_log(avctx, AV_LOG_ERROR, "Id header is too short\n");
+         av_log(s, AV_LOG_ERROR, "Id header is too short\n");
          return AVERROR_INVALIDDATA;
      }
  
      /* make sure this is the Id header */
      if (buf[0] != 1) {
-         av_log(avctx, AV_LOG_ERROR, "Wrong packet type in Id header\n");
+         av_log(s, AV_LOG_ERROR, "Wrong packet type in Id header\n");
          return AVERROR_INVALIDDATA;
      }
  
      /* check for header signature */
      if (memcmp(&buf[1], "vorbis", 6)) {
-         av_log(avctx, AV_LOG_ERROR, "Invalid packet signature in Id header\n");
+         av_log(s, AV_LOG_ERROR, "Invalid packet signature in Id header\n");
          return AVERROR_INVALIDDATA;
      }
  
      if (!(buf[29] & 0x1)) {
-         av_log(avctx, AV_LOG_ERROR, "Invalid framing bit in Id header\n");
+         av_log(s, AV_LOG_ERROR, "Invalid framing bit in Id header\n");
          return AVERROR_INVALIDDATA;
      }
  
@@@ -62,7 -70,7 +70,7 @@@
      return 0;
  }
  
- static int parse_setup_header(AVCodecContext *avctx, VorbisParseContext *s,
+ static int parse_setup_header(VorbisParseContext *s,
                                const uint8_t *buf, int buf_size)
  {
      GetBitContext gb, gb0;
  
      /* avoid overread */
      if (buf_size < 7) {
-         av_log(avctx, AV_LOG_ERROR, "Setup header is too short\n");
+         av_log(s, AV_LOG_ERROR, "Setup header is too short\n");
          return AVERROR_INVALIDDATA;
      }
  
      /* make sure this is the Setup header */
      if (buf[0] != 5) {
-         av_log(avctx, AV_LOG_ERROR, "Wrong packet type in Setup header\n");
+         av_log(s, AV_LOG_ERROR, "Wrong packet type in Setup header\n");
          return AVERROR_INVALIDDATA;
      }
  
      /* check for header signature */
      if (memcmp(&buf[1], "vorbis", 6)) {
-         av_log(avctx, AV_LOG_ERROR, "Invalid packet signature in Setup header\n");
+         av_log(s, AV_LOG_ERROR, "Invalid packet signature in Setup header\n");
          return AVERROR_INVALIDDATA;
      }
  
      /* reverse bytes so we can easily read backwards with get_bits() */
      if (!(rev_buf = av_malloc(buf_size))) {
-         av_log(avctx, AV_LOG_ERROR, "Out of memory\n");
+         av_log(s, AV_LOG_ERROR, "Out of memory\n");
          return AVERROR(ENOMEM);
      }
      for (i = 0; i < buf_size; i++)
          }
      }
      if (!got_framing_bit) {
-         av_log(avctx, AV_LOG_ERROR, "Invalid Setup header\n");
+         av_log(s, AV_LOG_ERROR, "Invalid Setup header\n");
          ret = AVERROR_INVALIDDATA;
          goto bad_header;
      }
          }
      }
      if (!got_mode_header) {
-         av_log(avctx, AV_LOG_ERROR, "Invalid Setup header\n");
+         av_log(s, AV_LOG_ERROR, "Invalid Setup header\n");
          ret = AVERROR_INVALIDDATA;
          goto bad_header;
      }
       * we may need to approach this the long way and parse the whole Setup
       * header, but I hope very much that it never comes to that. */
      if (last_mode_count > 2) {
-         avpriv_request_sample(avctx,
+         avpriv_request_sample(s,
                                "%d modes (either a false positive or a "
                                "sample from an unknown encoder)",
                                last_mode_count);
      /* We're limiting the mode count to 63 so that we know that the previous
       * block flag will be in the first packet byte. */
      if (last_mode_count > 63) {
-         av_log(avctx, AV_LOG_ERROR, "Unsupported mode count: %d\n",
+         av_log(s, AV_LOG_ERROR, "Unsupported mode count: %d\n",
                 last_mode_count);
          ret = AVERROR_INVALIDDATA;
          goto bad_header;
      skip_bits_long(&gb, got_framing_bit);
      for (i = mode_count - 1; i >= 0; i--) {
          skip_bits_long(&gb, 40);
 -        s->mode_blocksize[i] = s->blocksize[get_bits1(&gb)];
 +        s->mode_blocksize[i] = get_bits1(&gb);
      }
  
  bad_header:
@@@ -179,30 -187,30 +187,30 @@@ int avpriv_vorbis_parse_extradata(AVCod
      int header_len[3];
      int ret;
  
-     s->avctx = avctx;
+     s->class = &vorbis_parser_class;
      s->extradata_parsed = 1;
  
      if ((ret = avpriv_split_xiph_headers(avctx->extradata,
                                           avctx->extradata_size, 30,
                                           header_start, header_len)) < 0) {
-         av_log(avctx, AV_LOG_ERROR, "Extradata corrupt.\n");
+         av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
          return ret;
      }
  
-     if ((ret = parse_id_header(avctx, s, header_start[0], header_len[0])) < 0)
+     if ((ret = parse_id_header(s, header_start[0], header_len[0])) < 0)
          return ret;
  
-     if ((ret = parse_setup_header(avctx, s, header_start[2], header_len[2])) < 0)
+     if ((ret = parse_setup_header(s, header_start[2], header_len[2])) < 0)
          return ret;
  
      s->valid_extradata = 1;
 -    s->previous_blocksize = s->mode_blocksize[0];
 +    s->previous_blocksize = s->blocksize[s->mode_blocksize[0]];
  
      return 0;
  }
  
 -int avpriv_vorbis_parse_frame(VorbisParseContext *s, const uint8_t *buf,
 -                              int buf_size)
 +int avpriv_vorbis_parse_frame_flags(VorbisParseContext *s, const uint8_t *buf,
 +                                    int buf_size, int *flags)
  {
      int duration = 0;
  
          int previous_blocksize = s->previous_blocksize;
  
          if (buf[0] & 1) {
-             av_log(s->avctx, AV_LOG_ERROR, "Invalid packet\n");
 +            /* If the user doesn't care about special packets, it's a bad one. */
 +            if (!flags)
 +                goto bad_packet;
 +
 +            /* Set the flag for which kind of special packet it is. */
 +            if (buf[0] == 1)
 +                *flags |= VORBIS_FLAG_HEADER;
 +            else if (buf[0] == 3)
 +                *flags |= VORBIS_FLAG_COMMENT;
 +            else
 +                goto bad_packet;
 +
 +            /* Special packets have no duration. */
 +            return 0;
 +
 +bad_packet:
+             av_log(s, AV_LOG_ERROR, "Invalid packet\n");
              return AVERROR_INVALIDDATA;
          }
          if (s->mode_count == 1)
          else
              mode = (buf[0] & s->mode_mask) >> 1;
          if (mode >= s->mode_count) {
-             av_log(s->avctx, AV_LOG_ERROR, "Invalid mode in packet\n");
+             av_log(s, AV_LOG_ERROR, "Invalid mode in packet\n");
              return AVERROR_INVALIDDATA;
          }
 -        if (mode) {
 +        if(s->mode_blocksize[mode]){
              int flag = !!(buf[0] & s->prev_mask);
              previous_blocksize = s->blocksize[flag];
          }
 -        current_blocksize     = s->mode_blocksize[mode];
 +        current_blocksize     = s->blocksize[s->mode_blocksize[mode]];
          duration              = (previous_blocksize + current_blocksize) >> 2;
          s->previous_blocksize = current_blocksize;
      }
      return duration;
  }
  
 +int avpriv_vorbis_parse_frame(VorbisParseContext *s, const uint8_t *buf,
 +                              int buf_size)
 +{
 +    return avpriv_vorbis_parse_frame_flags(s, buf, buf_size, NULL);
 +}
 +
  void avpriv_vorbis_parse_reset(VorbisParseContext *s)
  {
      if (s->valid_extradata)
 -        s->previous_blocksize = s->mode_blocksize[0];
 +        s->previous_blocksize = s->blocksize[0];
  }
  
  #if CONFIG_VORBIS_PARSER
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * Copyright (c) 2012 Justin Ruggles
   *
 - * 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
   */
  
@@@ -31,7 -31,7 +31,7 @@@
  #include "avcodec.h"
  
  typedef struct VorbisParseContext {
-     AVCodecContext *avctx;      ///< codec context
+     const AVClass *class;
      int extradata_parsed;       ///< we have attempted to parse extradata
      int valid_extradata;        ///< extradata is valid, so we can calculate duration
      int blocksize[2];           ///< short and long window sizes
   */
  int avpriv_vorbis_parse_extradata(AVCodecContext *avctx, VorbisParseContext *s);
  
 +#define VORBIS_FLAG_HEADER  0x00000001
 +#define VORBIS_FLAG_COMMENT 0x00000002
 +
 +/**
 + * Get the duration for a Vorbis packet.
 + *
 + * avpriv_vorbis_parse_extradata() must have been successfully called prior to
 + * this in order for a correct duration to be returned. If @p flags is @c NULL,
 + * special frames are considered invalid.
 + *
 + * @param s        Vorbis parser context
 + * @param buf      buffer containing a Vorbis frame
 + * @param buf_size size of the buffer
 + * @param flags    flags for special frames
 + */
 +int avpriv_vorbis_parse_frame_flags(VorbisParseContext *s, const uint8_t *buf,
 +                                    int buf_size, int *flags);
 +
  /**
   * Get the duration for a Vorbis packet.
   *