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

diff --combined libavcodec/shorten.c
@@@ -2,20 -2,20 +2,20 @@@
   * Shorten decoder
   * Copyright (c) 2005 Jeff Muizelaar
   *
 - * 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
   */
  
  #define ENERGYSIZE 3
  #define BITSHIFTSIZE 2
  
 +#define TYPE_S8    1
 +#define TYPE_U8    2
  #define TYPE_S16HL 3
 +#define TYPE_U16HL 4
  #define TYPE_S16LH 5
 +#define TYPE_U16LH 6
  
  #define NWRAP 3
  #define NSKIPSIZE 1
@@@ -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;
          if (!tmp_ptr)
              return AVERROR(ENOMEM);
          s->decoded_base[chan] = tmp_ptr;
-         for (i=0; i<s->nwrap; i++)
+         for (i = 0; i < s->nwrap; i++)
              s->decoded_base[chan][i] = 0;
          s->decoded[chan] = s->decoded_base[chan] + s->nwrap;
      }
      return 0;
  }
  
  static inline unsigned int get_uint(ShortenContext *s, int k)
  {
      if (s->version != 0)
      return get_ur_golomb_shorten(&s->gb, k);
  }
  
  static void fix_bitshift(ShortenContext *s, int32_t *buffer)
  {
      int i;
              buffer[i] <<= s->bitshift;
  }
  
  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);
  
      if (len < 16) {
          av_log(avctx, AV_LOG_ERROR, "fmt chunk was too short\n");
 -        return -1;
 +        return AVERROR_INVALIDDATA;
      }
  
      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)
      avctx->sample_rate = bytestream_get_le32(&header);
      header += 4;        // skip bit rate    (represents original uncompressed bit rate)
      header += 2;        // skip block align (not needed)
 -    avctx->bits_per_coded_sample = bytestream_get_le16(&header);
 +    bps     = bytestream_get_le16(&header);
 +    avctx->bits_per_coded_sample = bps;
  
 -    if (avctx->bits_per_coded_sample != 16) {
 -        av_log(avctx, AV_LOG_ERROR, "unsupported number of bits per sample\n");
 -        return -1;
 +    if (bps != 16 && bps != 8) {
 +        av_log(avctx, AV_LOG_ERROR, "unsupported number of bits per sample: %d\n", bps);
 +        return AVERROR_INVALIDDATA;
      }
  
      len -= 16;
      return 0;
  }
  
 -static void output_buffer(int16_t **samples, int nchan, int blocksize,
 -                          int32_t **buffer)
 -{
 -    int i, ch;
 -    for (ch = 0; ch < nchan; ch++) {
 -        int32_t *in  = buffer[ch];
 -        int16_t *out = samples[ch];
 -        for (i = 0; i < blocksize; i++)
 -            out[i] = av_clip_int16(in[i]);
 -    }
 -}
 -
  static const int fixed_coeffs[3][3] = {
      { 1,  0,  0 },
      { 2, -1,  0 },
@@@ -282,11 -282,12 +281,12 @@@ static int decode_subframe_lpc(ShortenC
          /* read/validate prediction order */
          pred_order = get_ur_golomb_shorten(&s->gb, LPCQSIZE);
          if (pred_order > s->nwrap) {
-             av_log(s->avctx, AV_LOG_ERROR, "invalid pred_order %d\n", pred_order);
+             av_log(s->avctx, AV_LOG_ERROR, "invalid pred_order %d\n",
+                    pred_order);
              return AVERROR(EINVAL);
          }
          /* read LPC coefficients */
-         for (i=0; i<pred_order; i++)
+         for (i = 0; i < pred_order; i++)
              s->coeffs[i] = get_sr_golomb_shorten(&s->gb, LPCQUANT);
          coeffs = s->coeffs;
  
      } else {
          /* fixed LPC coeffs */
          pred_order = command;
-         coeffs     = fixed_coeffs[pred_order-1];
+         coeffs     = fixed_coeffs[pred_order - 1];
          qshift     = 0;
      }
  
  
      /* decode residual and do LPC prediction */
      init_sum = pred_order ? (command == FN_QLPC ? s->lpcqoffset : 0) : coffset;
-     for (i=0; i < s->blocksize; i++) {
+     for (i = 0; i < s->blocksize; i++) {
          sum = init_sum;
-         for (j=0; j<pred_order; j++)
-             sum += coeffs[j] * s->decoded[channel][i-j-1];
-         s->decoded[channel][i] = get_sr_golomb_shorten(&s->gb, residual_size) + (sum >> qshift);
+         for (j = 0; j < pred_order; j++)
+             sum += coeffs[j] * s->decoded[channel][i - j - 1];
+         s->decoded[channel][i] = get_sr_golomb_shorten(&s->gb, residual_size) +
+                                  (sum >> qshift);
      }
  
      /* add offset to current samples */
@@@ -327,20 -329,20 +328,20 @@@ 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);
      if (s->channels <= 0 || s->channels > MAX_CHANNELS) {
          av_log(s->avctx, AV_LOG_ERROR, "too many channels: %d\n", s->channels);
          s->channels = 0;
 -        return -1;
 +        return AVERROR_INVALIDDATA;
      }
      s->avctx->channels = s->channels;
  
          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->blocksize = blocksize;
  
-         maxnlpc = get_uint(s, LPCQSIZE);
+         maxnlpc  = get_uint(s, LPCQSIZE);
          s->nmean = get_uint(s, 0);
  
          skip_bytes = get_uint(s, NSKIPSIZE);
-         for (i=0; i<skip_bytes; i++) {
+         for (i = 0; i < skip_bytes; i++)
              skip_bits(&s->gb, 8);
-         }
      }
      s->nwrap = FFMAX(NWRAP, maxnlpc);
  
          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;
@@@ -405,15 -410,15 +409,15 @@@ static int shorten_decode_frame(AVCodec
  {
      AVFrame *frame     = data;
      const uint8_t *buf = avpkt->data;
-     int buf_size = avpkt->size;
-     ShortenContext *s = avctx->priv_data;
+     int buf_size       = avpkt->size;
+     ShortenContext *s  = avctx->priv_data;
      int i, input_buf_size = 0;
      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) {
      }
  
      /* append current packet data to bitstream buffer */
-     if(1 && s->max_framesize){//FIXME truncated
-         buf_size= FFMIN(buf_size, s->max_framesize - s->bitstream_size);
-         input_buf_size= buf_size;
-         if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
-             memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
-             s->bitstream_index=0;
+     if (1 && s->max_framesize) { //FIXME truncated
+         buf_size       = FFMIN(buf_size, s->max_framesize - s->bitstream_size);
+         input_buf_size = buf_size;
+         if (s->bitstream_index + s->bitstream_size + buf_size >
+             s->allocated_bitstream_size) {
+             memmove(s->bitstream, &s->bitstream[s->bitstream_index],
+                     s->bitstream_size);
+             s->bitstream_index = 0;
          }
          if (buf)
-             memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
-         buf= &s->bitstream[s->bitstream_index];
-         buf_size += s->bitstream_size;
-         s->bitstream_size= buf_size;
+             memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf,
+                    buf_size);
+         buf               = &s->bitstream[s->bitstream_index];
+         buf_size         += s->bitstream_size;
+         s->bitstream_size = buf_size;
  
          /* do not decode until buffer has at least max_framesize bytes or
-            the end of the file has been reached */
+          * the end of the file has been reached */
          if (buf_size < s->max_framesize && avpkt->data) {
              *got_frame_ptr = 0;
              return input_buf_size;
          }
      }
      /* init and position bitstream reader */
-     init_get_bits(&s->gb, buf, buf_size*8);
+     init_get_bits(&s->gb, buf, buf_size * 8);
      skip_bits(&s->gb, s->bitindex);
  
      /* process header or next subblock */
          unsigned cmd;
          int len;
  
-         if (get_bits_left(&s->gb) < 3+FNSIZE) {
+         if (get_bits_left(&s->gb) < 3 + FNSIZE) {
              *got_frame_ptr = 0;
              break;
          }
          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;
                  coffset = s->offset[channel][0];
              else {
                  int32_t sum = (s->version < 2) ? 0 : s->nmean / 2;
-                 for (i=0; i<s->nmean; i++)
+                 for (i = 0; i < s->nmean; i++)
                      sum += s->offset[channel][i];
                  coffset = sum / s->nmean;
                  if (s->version >= 2)
 -                    coffset >>= FFMIN(1, s->bitshift);
 +                    coffset = s->bitshift == 0 ? coffset : coffset >> s->bitshift - 1 >> 1;
              }
  
              /* decode samples for this channel */
              if (cmd == FN_ZERO) {
-                 for (i=0; i<s->blocksize; i++)
+                 for (i = 0; i < s->blocksize; i++)
                      s->decoded[channel][i] = 0;
              } else {
-                 if ((ret = decode_subframe_lpc(s, cmd, channel, residual_size, coffset)) < 0)
+                 if ((ret = decode_subframe_lpc(s, cmd, channel,
+                                                residual_size, coffset)) < 0)
                      return ret;
              }
  
              /* update means with info from the current block */
              if (s->nmean > 0) {
                  int32_t sum = (s->version < 2) ? 0 : s->blocksize / 2;
-                 for (i=0; i<s->blocksize; i++)
+                 for (i = 0; i < s->blocksize; i++)
                      sum += s->decoded[channel][i];
  
-                 for (i=1; i<s->nmean; i++)
-                     s->offset[channel][i-1] = s->offset[channel][i];
+                 for (i = 1; i < s->nmean; i++)
+                     s->offset[channel][i - 1] = s->offset[channel][i];
  
                  if (s->version < 2)
                      s->offset[channel][s->nmean - 1] = sum / s->blocksize;
              }
  
              /* copy wrap samples for use with next block */
-             for (i=-s->nwrap; i<0; i++)
+             for (i = -s->nwrap; i < 0; i++)
                  s->decoded[channel][i] = s->decoded[channel][i + s->blocksize];
  
              /* shift samples to add in unused zero bits which were removed
-                during encoding */
+              * during encoding */
              fix_bitshift(s, s->decoded[channel]);
  
              /* if this is the last channel in the block, output the samples */
              s->cur_chan++;
              if (s->cur_chan == s->channels) {
 +                uint8_t *samples_u8;
 +                int16_t *samples_s16;
 +                int chan;
 +
                  /* get output buffer */
                  frame->nb_samples = s->blocksize;
                  if ((ret = ff_get_buffer(avctx, frame)) < 0) {
                      av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
                      return ret;
                  }
 -                /* interleave output */
 -                output_buffer((int16_t **)frame->extended_data, s->channels,
 -                              s->blocksize, s->decoded);
 +
 +                for (chan = 0; chan < s->channels; chan++) {
 +                    samples_u8  = ((uint8_t **)frame->extended_data)[chan];
 +                    samples_s16 = ((int16_t **)frame->extended_data)[chan];
 +                    for (i = 0; i < s->blocksize; i++) {
 +                        switch (s->internal_ftype) {
 +                        case TYPE_U8:
 +                            *samples_u8++ = av_clip_uint8(s->decoded[chan][i]);
 +                            break;
 +                        case TYPE_S16HL:
 +                        case TYPE_S16LH:
 +                            *samples_s16++ = av_clip_int16(s->decoded[chan][i]);
 +                            break;
 +                        }
 +                    }
 +                }
  
                  *got_frame_ptr = 1;
              }
          *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;
@@@ -655,6 -647,5 +663,6 @@@ AVCodec ff_shorten_decoder = 
      .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_DR1,
      .long_name      = NULL_IF_CONFIG_SMALL("Shorten"),
      .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
 +                                                      AV_SAMPLE_FMT_U8P,
                                                        AV_SAMPLE_FMT_NONE },
  };