Merge commit 'a2ad554def214d2d03b7c16f68dc081a8622f9ca'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 6 Mar 2013 22:39:52 +0000 (23:39 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 6 Mar 2013 22:39:52 +0000 (23:39 +0100)
* commit 'a2ad554def214d2d03b7c16f68dc081a8622f9ca':
  shorten: K&R formatting cosmetics

Conflicts:
libavcodec/shorten.c

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

@@@ -112,10 -108,11 +112,10 @@@ typedef struct ShortenContext 
      int got_quit_command;
  } ShortenContext;
  
- static av_cold int shorten_decode_init(AVCodecContext * avctx)
+ static av_cold int shorten_decode_init(AVCodecContext *avctx)
  {
      ShortenContext *s = avctx->priv_data;
-     s->avctx = avctx;
+     s->avctx          = avctx;
 -    avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
  
      return 0;
  }
@@@ -126,17 -123,20 +126,20 @@@ static int allocate_buffers(ShortenCont
      int *coeffs;
      void *tmp_ptr;
  
-     for (chan=0; chan<s->channels; chan++) {
-         if(FFMAX(1, s->nmean) >= UINT_MAX/sizeof(int32_t)){
+     for (chan = 0; chan < s->channels; chan++) {
+         if (FFMAX(1, s->nmean) >= UINT_MAX / sizeof(int32_t)) {
              av_log(s->avctx, AV_LOG_ERROR, "nmean too large\n");
 -            return -1;
 +            return AVERROR_INVALIDDATA;
          }
-         if(s->blocksize + s->nwrap >= UINT_MAX/sizeof(int32_t) || s->blocksize + s->nwrap <= (unsigned)s->nwrap){
-             av_log(s->avctx, AV_LOG_ERROR, "s->blocksize + s->nwrap too large\n");
+         if (s->blocksize + s->nwrap >= UINT_MAX / sizeof(int32_t) ||
+             s->blocksize + s->nwrap <= (unsigned)s->nwrap) {
+             av_log(s->avctx, AV_LOG_ERROR,
+                    "s->blocksize + s->nwrap too large\n");
 -            return -1;
 +            return AVERROR_INVALIDDATA;
          }
  
-         tmp_ptr = av_realloc(s->offset[chan], sizeof(int32_t)*FFMAX(1, s->nmean));
+         tmp_ptr =
+             av_realloc(s->offset[chan], sizeof(int32_t) * FFMAX(1, s->nmean));
          if (!tmp_ptr)
              return AVERROR(ENOMEM);
          s->offset[chan] = tmp_ptr;
@@@ -180,23 -178,17 +181,21 @@@ static void fix_bitshift(ShortenContex
  static int init_offset(ShortenContext *s)
  {
      int32_t mean = 0;
-     int  chan, i;
+     int chan, i;
      int nblock = FFMAX(1, s->nmean);
      /* initialise offset */
-     switch (s->internal_ftype)
-     {
-         case TYPE_U8:
-             s->avctx->sample_fmt = AV_SAMPLE_FMT_U8P;
-             mean = 0x80;
-             break;
-         case TYPE_S16HL:
-         case TYPE_S16LH:
-             s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
-             break;
-         default:
-             av_log(s->avctx, AV_LOG_ERROR, "unknown audio type\n");
-             return AVERROR_PATCHWELCOME;
+     switch (s->internal_ftype) {
++    case TYPE_U8:
++        s->avctx->sample_fmt = AV_SAMPLE_FMT_U8P;
++        mean = 0x80;
++        break;
+     case TYPE_S16HL:
+     case TYPE_S16LH:
 -        mean = 0;
++        s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
+         break;
+     default:
 -        av_log(s->avctx, AV_LOG_ERROR, "unknown audio type");
 -        return AVERROR_INVALIDDATA;
++        av_log(s->avctx, AV_LOG_ERROR, "unknown audio type\n");
++        return AVERROR_PATCHWELCOME;
      }
  
      for (chan = 0; chan < s->channels; chan++)
  static int decode_wave_header(AVCodecContext *avctx, const uint8_t *header,
                                int header_size)
  {
 -    int len;
 +    int len, bps;
      short wave_format;
 +    const uint8_t *end= header + header_size;
  
-     if (bytestream_get_le32(&header) != MKTAG('R','I','F','F')) {
+     if (bytestream_get_le32(&header) != MKTAG('R', 'I', 'F', 'F')) {
          av_log(avctx, AV_LOG_ERROR, "missing RIFF tag\n");
 -        return -1;
 +        return AVERROR_INVALIDDATA;
      }
  
-     header += 4; /* chunk size */;
+     header += 4; /* chunk size */
  
-     if (bytestream_get_le32(&header) != MKTAG('W','A','V','E')) {
+     if (bytestream_get_le32(&header) != MKTAG('W', 'A', 'V', 'E')) {
          av_log(avctx, AV_LOG_ERROR, "missing WAVE tag\n");
 -        return -1;
 +        return AVERROR_INVALIDDATA;
      }
  
-     while (bytestream_get_le32(&header) != MKTAG('f','m','t',' ')) {
-         len = bytestream_get_le32(&header);
-         if(len<0 || end - header - 8 < len)
+     while (bytestream_get_le32(&header) != MKTAG('f', 'm', 't', ' ')) {
+         len     = bytestream_get_le32(&header);
++        if (len<0 || end - header - 8 < len)
 +            return AVERROR_INVALIDDATA;
          header += len;
      }
      len = bytestream_get_le32(&header);
      wave_format = bytestream_get_le16(&header);
  
      switch (wave_format) {
-         case WAVE_FORMAT_PCM:
-             break;
-         default:
-             av_log(avctx, AV_LOG_ERROR, "unsupported wave format\n");
-             return AVERROR_PATCHWELCOME;
+     case WAVE_FORMAT_PCM:
+         break;
+     default:
+         av_log(avctx, AV_LOG_ERROR, "unsupported wave format\n");
 -        return -1;
++        return AVERROR_PATCHWELCOME;
      }
  
      header += 2;        // skip channels    (already got from shorten header)
@@@ -327,13 -329,13 +328,13 @@@ static int read_header(ShortenContext *
      /* shorten signature */
      if (get_bits_long(&s->gb, 32) != AV_RB32("ajkg")) {
          av_log(s->avctx, AV_LOG_ERROR, "missing shorten magic 'ajkg'\n");
 -        return -1;
 +        return AVERROR_INVALIDDATA;
      }
  
-     s->lpcqoffset = 0;
-     s->blocksize = DEFAULT_BLOCK_SIZE;
-     s->nmean = -1;
-     s->version = get_bits(&s->gb, 8);
+     s->lpcqoffset     = 0;
+     s->blocksize      = DEFAULT_BLOCK_SIZE;
+     s->nmean          = -1;
+     s->version        = get_bits(&s->gb, 8);
      s->internal_ftype = get_uint(s, TYPESIZE);
  
      s->channels = get_uint(s, CHANSIZE);
          int skip_bytes, blocksize;
  
          blocksize = get_uint(s, av_log2(DEFAULT_BLOCK_SIZE));
 -        if (!blocksize || blocksize > MAX_BLOCKSIZE) {
 +        if (!blocksize || blocksize > (unsigned)MAX_BLOCKSIZE) {
-             av_log(s->avctx, AV_LOG_ERROR, "invalid or unsupported block size: %d\n",
+             av_log(s->avctx, AV_LOG_ERROR,
+                    "invalid or unsupported block size: %d\n",
                     blocksize);
              return AVERROR(EINVAL);
          }
          s->lpcqoffset = V2LPCQOFFSET;
  
      if (get_ur_golomb_shorten(&s->gb, FNSIZE) != FN_VERBATIM) {
-         av_log(s->avctx, AV_LOG_ERROR, "missing verbatim section at beginning of stream\n");
+         av_log(s->avctx, AV_LOG_ERROR,
+                "missing verbatim section at beginning of stream\n");
 -        return -1;
 +        return AVERROR_INVALIDDATA;
      }
  
      s->header_size = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE);
-     if (s->header_size >= OUT_BUFFER_SIZE || s->header_size < CANONICAL_HEADER_SIZE) {
-         av_log(s->avctx, AV_LOG_ERROR, "header is wrong size: %d\n", s->header_size);
+     if (s->header_size >= OUT_BUFFER_SIZE ||
+         s->header_size < CANONICAL_HEADER_SIZE) {
+         av_log(s->avctx, AV_LOG_ERROR, "header is wrong size: %d\n",
+                s->header_size);
 -        return -1;
 +        return AVERROR_INVALIDDATA;
      }
  
-     for (i=0; i<s->header_size; i++)
+     for (i = 0; i < s->header_size; i++)
          s->header[i] = (char)get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE);
  
 -    if (decode_wave_header(s->avctx, s->header, s->header_size) < 0)
 -        return -1;
 +    if ((ret = decode_wave_header(s->avctx, s->header, s->header_size)) < 0)
 +        return ret;
  
      s->cur_chan = 0;
      s->bitshift = 0;
@@@ -411,9 -416,9 +415,9 @@@ static int shorten_decode_frame(AVCodec
      int ret;
  
      /* allocate internal bitstream buffer */
-     if(s->max_framesize == 0){
+     if (s->max_framesize == 0) {
          void *tmp_ptr;
-         s->max_framesize= 8192; // should hopefully be enough for the first header
 -        s->max_framesize = 1024; // should hopefully be enough for the first header
++        s->max_framesize = 8192; // should hopefully be enough for the first header
          tmp_ptr = av_fast_realloc(s->bitstream, &s->allocated_bitstream_size,
                                    s->max_framesize);
          if (!tmp_ptr) {
          if (!is_audio_command[cmd]) {
              /* process non-audio command */
              switch (cmd) {
-                 case FN_VERBATIM:
-                     len = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE);
-                     while (len--) {
-                         get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE);
-                     }
-                     break;
-                 case FN_BITSHIFT:
-                     s->bitshift = get_ur_golomb_shorten(&s->gb, BITSHIFTSIZE);
-                     break;
-                 case FN_BLOCKSIZE: {
-                     int blocksize = get_uint(s, av_log2(s->blocksize));
-                     if (blocksize > s->blocksize) {
-                         av_log(avctx, AV_LOG_ERROR, "Increasing block size is not supported\n");
-                         return AVERROR_PATCHWELCOME;
-                     }
-                     if (!blocksize || blocksize > (unsigned)MAX_BLOCKSIZE) {
-                         av_log(avctx, AV_LOG_ERROR, "invalid or unsupported "
-                                "block size: %d\n", blocksize);
-                         return AVERROR(EINVAL);
-                     }
-                     s->blocksize = blocksize;
-                     break;
+             case FN_VERBATIM:
+                 len = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE);
+                 while (len--)
+                     get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE);
+                 break;
+             case FN_BITSHIFT:
+                 s->bitshift = get_ur_golomb_shorten(&s->gb, BITSHIFTSIZE);
+                 break;
+             case FN_BLOCKSIZE: {
+                 int blocksize = get_uint(s, av_log2(s->blocksize));
+                 if (blocksize > s->blocksize) {
+                     av_log(avctx, AV_LOG_ERROR,
+                            "Increasing block size is not supported\n");
+                     return AVERROR_PATCHWELCOME;
                  }
-                 case FN_QUIT:
-                     s->got_quit_command = 1;
-                     break;
 -                if (!blocksize || blocksize > MAX_BLOCKSIZE) {
++                if (!blocksize || blocksize > (unsigned)MAX_BLOCKSIZE) {
+                     av_log(avctx, AV_LOG_ERROR, "invalid or unsupported "
+                                                 "block size: %d\n", blocksize);
+                     return AVERROR(EINVAL);
+                 }
+                 s->blocksize = blocksize;
+                 break;
+             }
+             case FN_QUIT:
+                 s->got_quit_command = 1;
+                 break;
              }
              if (cmd == FN_BLOCKSIZE || cmd == FN_QUIT) {
                  *got_frame_ptr = 0;
          *got_frame_ptr = 0;
  
  finish_frame:
-     s->bitindex = get_bits_count(&s->gb) - 8*((get_bits_count(&s->gb))/8);
-     i= (get_bits_count(&s->gb))/8;
+     s->bitindex = get_bits_count(&s->gb) - 8 * (get_bits_count(&s->gb) / 8);
+     i           = get_bits_count(&s->gb) / 8;
      if (i > buf_size) {
          av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
-         s->bitstream_size=0;
-         s->bitstream_index=0;
+         s->bitstream_size  = 0;
+         s->bitstream_index = 0;
 -        return -1;
 +        return AVERROR_INVALIDDATA;
      }
      if (s->bitstream_size) {
          s->bitstream_index += i;