Merge commit 'b522000e9b2ca36fe5b2751096b9a5f5ed8f87e6'
authorMichael Niedermayer <michaelni@gmx.at>
Thu, 11 Oct 2012 11:58:29 +0000 (13:58 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Thu, 11 Oct 2012 12:03:12 +0000 (14:03 +0200)
* commit 'b522000e9b2ca36fe5b2751096b9a5f5ed8f87e6':
  avio: introduce avio_closep
  mpegtsenc: set muxing type notification to verbose
  vc1dec: Use correct spelling of "opposite"
  a64multienc: change mc_frame_counter to unsigned
  arm: call arm-specific rv34dsp init functions under if (ARCH_ARM)
  svq1: Drop a bunch of useless parentheses
  parseutils-test: do not print numerical error codes
  svq1: K&R formatting cosmetics

Conflicts:
doc/APIchanges
libavcodec/svq1dec.c
libavcodec/svq1enc.c
libavformat/version.h
libavutil/parseutils.c
tests/ref/fate/parseutils

Merged-by: Michael Niedermayer <michaelni@gmx.at>
19 files changed:
1  2 
doc/APIchanges
libavcodec/a64enc.h
libavcodec/arm/rv34dsp_init_arm.c
libavcodec/arm/rv40dsp_init_arm.c
libavcodec/rv40dsp.c
libavcodec/svq1.c
libavcodec/svq1.h
libavcodec/svq13.c
libavcodec/svq1_vlc.h
libavcodec/svq1dec.c
libavcodec/svq1enc.c
libavcodec/svq1enc_cb.h
libavcodec/vc1dec.c
libavformat/avio.h
libavformat/aviobuf.c
libavformat/mpegtsenc.c
libavformat/version.h
libavutil/parseutils.c
tests/ref/fate/parseutils

diff --cc doc/APIchanges
@@@ -15,88 -13,9 +15,91 @@@ libavutil:     2011-04-1
  
  API changes, most recent first:
  
 +2012-09-27 - a70b493 - lavd 54.3.100 - version.h
 +  Add LIBAVDEVICE_IDENT symbol.
 +
 +2012-09-27 - a70b493 - lavfi 3.18.100 - version.h
 +  Add LIBAVFILTER_IDENT symbol.
 +
 +2012-09-27 - a70b493 - libswr 0.16.100 - version.h
 +  Add LIBSWRESAMPLE_VERSION, LIBSWRESAMPLE_BUILD
 +  and LIBSWRESAMPLE_IDENT symbols.
 +
 +2012-09-06 - 29e972f - lavu 51.72.100 - parseutils.h
 +  Add av_small_strptime() time parsing function.
 +
 +  Can be used as a stripped-down replacement for strptime(), on
 +  systems which do not support it.
 +
 +2012-08-25 - 2626cc4 - lavf 54.28.100
 +  Matroska demuxer now identifies SRT subtitles as AV_CODEC_ID_SUBRIP instead
 +  of AV_CODEC_ID_TEXT.
 +
 +2012-08-13 - 5c0d8bc - lavfi 3.8.100 - avfilter.h
 +  Add avfilter_get_class() function, and priv_class field to AVFilter
 +  struct.
 +
 +2012-08-12 - a25346e - lavu 51.69.100 - opt.h
 +  Add AV_OPT_FLAG_FILTERING_PARAM symbol in opt.h.
 +
 +2012-07-31 - 23fc4dd - lavc 54.46.100
 +  Add channels field to AVFrame.
 +
 +2012-07-30 - f893904 - lavu 51.66.100
 +  Add av_get_channel_description()
 +  and av_get_standard_channel_layout() functions.
 +
 +2012-07-21 - 016a472 - lavc 54.43.100
 +  Add decode_error_flags field to AVFrame.
 +
 +2012-07-20 - b062936 - lavf 54.18.100
 +  Add avformat_match_stream_specifier() function.
 +
 +2012-07-14 - f49ec1b - lavc 54.38.100 - avcodec.h
 +  Add metadata to AVFrame, and the accessor functions
 +  av_frame_get_metadata() and av_frame_set_metadata().
 +
 +2012-07-10 - 0e003d8 - lavc 54.33.100
 +  Add av_fast_padded_mallocz().
 +
 +2012-07-10 - 21d5609 - lavfi 3.2.0 - avfilter.h
 +  Add init_opaque() callback to AVFilter struct.
 +
 +2012-06-26 - e6674e4 - lavu 51.63.100 - imgutils.h
 +  Add functions to libavutil/imgutils.h:
 +  av_image_get_buffer_size()
 +  av_image_fill_arrays()
 +  av_image_copy_to_buffer()
 +
 +2012-06-24 - c41899a - lavu 51.62.100 - version.h
 +  version moved from avutil.h to version.h
 +
 +2012-04-11 - 359abb1 - lavu 51.58.100 - error.h
 +  Add av_make_error_string() and av_err2str() utilities to
 +  libavutil/error.h.
 +
 +2012-06-05 - 62b39d4 - lavc 54.24.100
 +  Add pkt_duration field to AVFrame.
 +
 +2012-05-24 - f2ee065 - lavu 51.54.100
 +  Move AVPALETTE_SIZE and AVPALETTE_COUNT macros from
 +  libavcodec/avcodec.h to libavutil/pixfmt.h.
 +
 +2012-05-14 - 94a9ac1 - lavf 54.5.100
 +  Add av_guess_sample_aspect_ratio() function.
 +
 +2012-04-20 - 65fa7bc - lavfi 2.70.100
 +  Add avfilter_unref_bufferp() to avfilter.h.
 +
 +2012-04-13 - 162e400 - lavfi 2.68.100
 +  Install libavfilter/asrc_abuffer.h public header.
 +
 +2012-03-26 - a67d9cf - lavfi 2.66.100
 +  Add avfilter_fill_frame_from_{audio_,}buffer_ref() functions.
 +
+ 2012-10-xx - xxxxxxx - lavf 54.18.0 - avio.h
+   Add avio_closep to complement avio_close.
  2012-10-xx - xxxxxxx - lavu 51.42.0 - pixfmt.h
    Rename PixelFormat to AVPixelFormat and all PIX_FMT_* to AV_PIX_FMT_*.
    To provide backwards compatibility, PixelFormat is now #defined as
Simple merge
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * Copyright (c) 2011 Janne Grunau <janne-libav@jannau.net>
   *
-- * 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
   */
  
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * Copyright (c) 2011 Janne Grunau <janne-libav@jannau.net>
   *
-- * 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
   */
  
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -59,650 -57,663 +57,665 @@@ typedef struct svq1_pmv_s 
  } svq1_pmv;
  
  static const uint8_t string_table[256] = {
-   0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
-   0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
-   0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
-   0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
-   0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
-   0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
-   0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
-   0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
-   0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
-   0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
-   0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
-   0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
-   0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
-   0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
-   0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
-   0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
-   0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
-   0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
-   0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
-   0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
-   0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
-   0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
-   0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
-   0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
-   0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
-   0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
-   0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
-   0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
-   0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
-   0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
-   0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
-   0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
+     0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
+     0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
+     0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
+     0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
+     0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
+     0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
+     0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
+     0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
+     0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
+     0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
+     0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
+     0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
+     0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
+     0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
+     0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
+     0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
+     0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
+     0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
+     0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
+     0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
+     0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
+     0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
+     0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
+     0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
+     0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
+     0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
+     0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
+     0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
+     0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
+     0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
+     0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
+     0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
  };
  
- #define SVQ1_PROCESS_VECTOR()\
-     for (; level > 0; i++) {\
-       /* process next depth */\
-       if (i == m) {\
-         m = n;\
-         if (--level == 0)\
-           break;\
-       }\
-       /* divide block if next bit set */\
-       if (get_bits1 (bitbuf) == 0)\
-         break;\
-       /* add child nodes */\
-       list[n++] = list[i];\
-       list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
+ #define SVQ1_PROCESS_VECTOR()                                           \
+     for (; level > 0; i++) {                                            \
+         /* process next depth */                                        \
+         if (i == m) {                                                   \
+             m = n;                                                      \
+             if (--level == 0)                                           \
+                 break;                                                  \
+         }                                                               \
+         /* divide block if next bit set */                              \
+         if (get_bits1(bitbuf) == 0)                                     \
+             break;                                                      \
+         /* add child nodes */                                           \
+         list[n++] = list[i];                                            \
 -        list[n++] = list[i] +                                           \
 -                    (((level & 1) ? pitch : 1) << (level / 2 + 1));     \
++        list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
      }
  
- #define SVQ1_ADD_CODEBOOK()\
-           /* add codebook entries to vector */\
-           for (j=0; j < stages; j++) {\
-             n3  = codebook[entries[j]] ^ 0x80808080;\
-             n1 += ((n3 & 0xFF00FF00) >> 8);\
-             n2 +=  (n3 & 0x00FF00FF);\
-           }\
- \
-           /* clip to [0..255] */\
-           if (n1 & 0xFF00FF00) {\
-             n3  = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
-             n1 += 0x7F007F00;\
-             n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
-             n1 &= (n3 & 0x00FF00FF);\
-           }\
- \
-           if (n2 & 0xFF00FF00) {\
-             n3  = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
-             n2 += 0x7F007F00;\
-             n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
-             n2 &= (n3 & 0x00FF00FF);\
-           }
- #define SVQ1_DO_CODEBOOK_INTRA()\
-       for (y=0; y < height; y++) {\
-         for (x=0; x < (width / 4); x++, codebook++) {\
-         n1 = n4;\
-         n2 = n4;\
-         SVQ1_ADD_CODEBOOK()\
-         /* store result */\
-         dst[x] = (n1 << 8) | n2;\
-         }\
-         dst += (pitch / 4);\
-       }
- #define SVQ1_DO_CODEBOOK_NONINTRA()\
-       for (y=0; y < height; y++) {\
-         for (x=0; x < (width / 4); x++, codebook++) {\
-         n3 = dst[x];\
-         /* add mean value to vector */\
-         n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
-         n2 =  (n3 & 0x00FF00FF)          + n4;\
-         SVQ1_ADD_CODEBOOK()\
-         /* store result */\
-         dst[x] = (n1 << 8) | n2;\
-         }\
-         dst += (pitch / 4);\
-       }
- #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
-       codebook = (const uint32_t *) cbook[level];\
-       if (stages > 0)\
-         bit_cache = get_bits (bitbuf, 4*stages);\
-       /* calculate codebook entries for this vector */\
-       for (j=0; j < stages; j++) {\
-         entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
-       }\
-       mean -= (stages * 128);\
-       n4    = (mean << 16) + mean;
- static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
-   uint32_t    bit_cache;
-   uint8_t    *list[63];
-   uint32_t   *dst;
-   const uint32_t *codebook;
-   int         entries[6];
-   int         i, j, m, n;
-   int         mean, stages;
-   unsigned    x, y, width, height, level;
-   uint32_t    n1, n2, n3, n4;
-   /* initialize list for breadth first processing of vectors */
-   list[0] = pixels;
-   /* recursively process vector */
-   for (i=0, m=1, n=1, level=5; i < n; i++) {
-     SVQ1_PROCESS_VECTOR();
-     /* destination address and vector size */
-     dst = (uint32_t *) list[i];
-     width = 1 << ((4 + level) /2);
-     height = 1 << ((3 + level) /2);
-     /* get number of stages (-1 skips vector, 0 for mean only) */
-     stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
-     if (stages == -1) {
-         for (y=0; y < height; y++) {
-           memset (&dst[y*(pitch / 4)], 0, width);
-         }
-       continue;                 /* skip vector */
+ #define SVQ1_ADD_CODEBOOK()                                             \
+     /* add codebook entries to vector */                                \
+     for (j = 0; j < stages; j++) {                                      \
+         n3  = codebook[entries[j]] ^ 0x80808080;                        \
+         n1 += (n3 & 0xFF00FF00) >> 8;                                   \
+         n2 +=  n3 & 0x00FF00FF;                                         \
+     }                                                                   \
+                                                                         \
+     /* clip to [0..255] */                                              \
+     if (n1 & 0xFF00FF00) {                                              \
+         n3  = (n1 >> 15  & 0x00010001 | 0x01000100) - 0x00010001;       \
+         n1 += 0x7F007F00;                                               \
+         n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001;       \
+         n1 &= n3 & 0x00FF00FF;                                          \
+     }                                                                   \
+                                                                         \
+     if (n2 & 0xFF00FF00) {                                              \
+         n3  = (n2 >> 15  & 0x00010001 | 0x01000100) - 0x00010001;       \
+         n2 += 0x7F007F00;                                               \
+         n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001;       \
+         n2 &= n3 & 0x00FF00FF;                                          \
      }
  
-     if ((stages > 0) && (level >= 4)) {
-       av_dlog(NULL,
-               "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
-               stages, level);
-       return -1;        /* invalid vector */
+ #define SVQ1_DO_CODEBOOK_INTRA()                                        \
+     for (y = 0; y < height; y++) {                                      \
+         for (x = 0; x < width / 4; x++, codebook++) {                   \
+             n1 = n4;                                                    \
+             n2 = n4;                                                    \
+             SVQ1_ADD_CODEBOOK()                                         \
+             /* store result */                                          \
+             dst[x] = n1 << 8 | n2;                                      \
+         }                                                               \
+         dst += pitch / 4;                                               \
      }
  
-     mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
+ #define SVQ1_DO_CODEBOOK_NONINTRA()                                     \
+     for (y = 0; y < height; y++) {                                      \
+         for (x = 0; x < width / 4; x++, codebook++) {                   \
+             n3 = dst[x];                                                \
+             /* add mean value to vector */                              \
+             n1 = n4 + ((n3 & 0xFF00FF00) >> 8);                         \
+             n2 = n4 +  (n3 & 0x00FF00FF);                               \
+             SVQ1_ADD_CODEBOOK()                                         \
+             /* store result */                                          \
+             dst[x] = n1 << 8 | n2;                                      \
+         }                                                               \
+         dst += pitch / 4;                                               \
+     }
  
-     if (stages == 0) {
-       for (y=0; y < height; y++) {
-         memset (&dst[y*(pitch / 4)], mean, width);
-       }
-     } else {
-       SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
-       SVQ1_DO_CODEBOOK_INTRA()
+ #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)                               \
+     codebook = (const uint32_t *)cbook[level];                          \
+     if (stages > 0)                                                     \
+         bit_cache = get_bits(bitbuf, 4 * stages);                       \
+     /* calculate codebook entries for this vector */                    \
+     for (j = 0; j < stages; j++) {                                      \
+         entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) +   \
+                       16 * j) << (level + 1);                           \
+     }                                                                   \
+     mean -= stages * 128;                                               \
 -    n4    = mean + (mean >> 31) << 16 | (mean & 0xFFFF);
++    n4    = (mean << 16) + mean;
+ static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
+                                    int pitch)
+ {
+     uint32_t bit_cache;
+     uint8_t *list[63];
+     uint32_t *dst;
+     const uint32_t *codebook;
+     int entries[6];
+     int i, j, m, n;
+     int mean, stages;
+     unsigned x, y, width, height, level;
+     uint32_t n1, n2, n3, n4;
+     /* initialize list for breadth first processing of vectors */
+     list[0] = pixels;
+     /* recursively process vector */
+     for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
+         SVQ1_PROCESS_VECTOR();
+         /* destination address and vector size */
+         dst    = (uint32_t *)list[i];
+         width  = 1 << ((4 + level) / 2);
+         height = 1 << ((3 + level) / 2);
+         /* get number of stages (-1 skips vector, 0 for mean only) */
+         stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
+         if (stages == -1) {
+             for (y = 0; y < height; y++)
+                 memset(&dst[y * (pitch / 4)], 0, width);
+             continue;   /* skip vector */
+         }
+         if (stages > 0 && level >= 4) {
+             av_dlog(NULL,
+                     "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
+                     stages, level);
+             return -1;  /* invalid vector */
+         }
+         mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
+         if (stages == 0) {
+             for (y = 0; y < height; y++)
+                 memset(&dst[y * (pitch / 4)], mean, width);
+         } else {
+             SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
+             SVQ1_DO_CODEBOOK_INTRA()
+         }
      }
-   }
  
-   return 0;
+     return 0;
  }
  
- static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
-   uint32_t    bit_cache;
-   uint8_t    *list[63];
-   uint32_t   *dst;
-   const uint32_t *codebook;
-   int         entries[6];
-   int         i, j, m, n;
-   int         mean, stages;
-   int         x, y, width, height, level;
-   uint32_t    n1, n2, n3, n4;
-   /* initialize list for breadth first processing of vectors */
-   list[0] = pixels;
-   /* recursively process vector */
-   for (i=0, m=1, n=1, level=5; i < n; i++) {
-     SVQ1_PROCESS_VECTOR();
-     /* destination address and vector size */
-     dst = (uint32_t *) list[i];
-     width = 1 << ((4 + level) /2);
-     height = 1 << ((3 + level) /2);
-     /* get number of stages (-1 skips vector, 0 for mean only) */
-     stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
-     if (stages == -1) continue; /* skip vector */
-     if ((stages > 0) && (level >= 4)) {
-       av_dlog(NULL,
-               "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
-               stages, level);
-       return -1;        /* invalid vector */
-     }
+ static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
+                                        int pitch)
+ {
+     uint32_t bit_cache;
+     uint8_t *list[63];
+     uint32_t *dst;
+     const uint32_t *codebook;
+     int entries[6];
+     int i, j, m, n;
+     int mean, stages;
+     int x, y, width, height, level;
+     uint32_t n1, n2, n3, n4;
+     /* initialize list for breadth first processing of vectors */
+     list[0] = pixels;
+     /* recursively process vector */
+     for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
+         SVQ1_PROCESS_VECTOR();
+         /* destination address and vector size */
+         dst    = (uint32_t *)list[i];
+         width  = 1 << ((4 + level) / 2);
+         height = 1 << ((3 + level) / 2);
+         /* get number of stages (-1 skips vector, 0 for mean only) */
+         stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
+         if (stages == -1)
+             continue;           /* skip vector */
+         if ((stages > 0) && (level >= 4)) {
+             av_dlog(NULL,
+                     "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
+                     stages, level);
+             return -1;  /* invalid vector */
+         }
  
-     mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
+         mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
  
-     SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
-     SVQ1_DO_CODEBOOK_NONINTRA()
-   }
-   return 0;
+         SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
+         SVQ1_DO_CODEBOOK_NONINTRA()
+     }
+     return 0;
  }
  
- static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv) {
-   int        diff;
-   int        i;
+ static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
+                                      svq1_pmv **pmv)
+ {
+     int diff;
+     int i;
  
-   for (i=0; i < 2; i++) {
+     for (i = 0; i < 2; i++) {
+         /* get motion code */
+         diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
+         if (diff < 0)
+             return -1;
+         else if (diff) {
+             if (get_bits1(bitbuf))
+                 diff = -diff;
+         }
  
-     /* get motion code */
-     diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
-     if(diff<0)
-         return -1;
-     else if(diff){
-         if(get_bits1(bitbuf)) diff= -diff;
+         /* add median of motion vector predictors and clip result */
+         if (i == 1)
+             mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
+         else
+             mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
      }
  
-     /* add median of motion vector predictors and clip result */
-     if (i == 1)
-       mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
-     else
-       mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
-   }
-   return 0;
+     return 0;
  }
  
- static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
-   uint8_t *src;
-   uint8_t *dst;
-   int      i;
+ static void svq1_skip_block(uint8_t *current, uint8_t *previous,
+                             int pitch, int x, int y)
+ {
+     uint8_t *src;
+     uint8_t *dst;
+     int i;
  
-   src = &previous[x + y*pitch];
-   dst = current;
+     src = &previous[x + y * pitch];
+     dst = current;
  
-   for (i=0; i < 16; i++) {
-     memcpy (dst, src, 16);
-     src += pitch;
-     dst += pitch;
-   }
+     for (i = 0; i < 16; i++) {
+         memcpy(dst, src, 16);
+         src += pitch;
+         dst += pitch;
+     }
  }
  
- static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
-                                uint8_t *current, uint8_t *previous, int pitch,
-                                svq1_pmv *motion, int x, int y) {
-   uint8_t    *src;
-   uint8_t    *dst;
-   svq1_pmv    mv;
-   svq1_pmv   *pmv[3];
-   int         result;
-   /* predict and decode motion vector */
-   pmv[0] = &motion[0];
-   if (y == 0) {
-     pmv[1] =
-     pmv[2] = pmv[0];
-   }
-   else {
-     pmv[1] = &motion[(x / 8) + 2];
-     pmv[2] = &motion[(x / 8) + 4];
-   }
-   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
-   if (result != 0)
-     return result;
+ static int svq1_motion_inter_block(MpegEncContext *s, GetBitContext *bitbuf,
+                                    uint8_t *current, uint8_t *previous,
+                                    int pitch, svq1_pmv *motion, int x, int y)
+ {
+     uint8_t *src;
+     uint8_t *dst;
+     svq1_pmv mv;
+     svq1_pmv *pmv[3];
+     int result;
+     /* predict and decode motion vector */
+     pmv[0] = &motion[0];
+     if (y == 0) {
+         pmv[1] =
+         pmv[2] = pmv[0];
+     } else {
+         pmv[1] = &motion[x / 8 + 2];
+         pmv[2] = &motion[x / 8 + 4];
+     }
  
-   motion[0].x                =
-   motion[(x / 8) + 2].x      =
-   motion[(x / 8) + 3].x      = mv.x;
-   motion[0].y                =
-   motion[(x / 8) + 2].y      =
-   motion[(x / 8) + 3].y      = mv.y;
+     result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
  
-   if(y + (mv.y >> 1)<0)
-      mv.y= 0;
-   if(x + (mv.x >> 1)<0)
-      mv.x= 0;
+     if (result != 0)
+         return result;
+     motion[0].x         =
+     motion[x / 8 + 2].x =
+     motion[x / 8 + 3].x = mv.x;
+     motion[0].y         =
+     motion[x / 8 + 2].y =
+     motion[x / 8 + 3].y = mv.y;
+     if (y + (mv.y >> 1) < 0)
+         mv.y = 0;
+     if (x + (mv.x >> 1) < 0)
+         mv.x = 0;
  
-   src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
-   dst = current;
+     src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
+     dst = current;
  
-   s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
+     s->dsp.put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
  
-   return 0;
+     return 0;
  }
  
- static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
-                                   uint8_t *current, uint8_t *previous, int pitch,
-                                   svq1_pmv *motion,int x, int y) {
-   uint8_t    *src;
-   uint8_t    *dst;
-   svq1_pmv    mv;
-   svq1_pmv   *pmv[4];
-   int         i, result;
-   /* predict and decode motion vector (0) */
-   pmv[0] = &motion[0];
-   if (y == 0) {
-     pmv[1] =
-     pmv[2] = pmv[0];
-   }
-   else {
-     pmv[1] = &motion[(x / 8) + 2];
-     pmv[2] = &motion[(x / 8) + 4];
-   }
-   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
-   if (result != 0)
-     return result;
+ static int svq1_motion_inter_4v_block(MpegEncContext *s, GetBitContext *bitbuf,
+                                       uint8_t *current, uint8_t *previous,
+                                       int pitch, svq1_pmv *motion, int x, int y)
+ {
+     uint8_t *src;
+     uint8_t *dst;
+     svq1_pmv mv;
+     svq1_pmv *pmv[4];
+     int i, result;
+     /* predict and decode motion vector (0) */
+     pmv[0] = &motion[0];
+     if (y == 0) {
+         pmv[1] =
+         pmv[2] = pmv[0];
+     } else {
+         pmv[1] = &motion[(x / 8) + 2];
+         pmv[2] = &motion[(x / 8) + 4];
+     }
  
-   /* predict and decode motion vector (1) */
-   pmv[0] = &mv;
-   if (y == 0) {
-     pmv[1] =
-     pmv[2] = pmv[0];
-   }
-   else {
-     pmv[1] = &motion[(x / 8) + 3];
-   }
-   result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
-   if (result != 0)
-     return result;
+     result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
  
-   /* predict and decode motion vector (2) */
-   pmv[1] = &motion[0];
-   pmv[2] = &motion[(x / 8) + 1];
+     if (result != 0)
+         return result;
  
-   result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
+     /* predict and decode motion vector (1) */
+     pmv[0] = &mv;
+     if (y == 0) {
+         pmv[1] =
+         pmv[2] = pmv[0];
+     } else {
+         pmv[1] = &motion[(x / 8) + 3];
+     }
+     result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
  
-   if (result != 0)
-     return result;
+     if (result != 0)
+         return result;
  
-   /* predict and decode motion vector (3) */
-   pmv[2] = &motion[(x / 8) + 2];
-   pmv[3] = &motion[(x / 8) + 3];
+     /* predict and decode motion vector (2) */
+     pmv[1] = &motion[0];
+     pmv[2] = &motion[(x / 8) + 1];
  
-   result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
+     result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
  
-   if (result != 0)
-     return result;
+     if (result != 0)
+         return result;
  
-   /* form predictions */
-   for (i=0; i < 4; i++) {
-     int mvx= pmv[i]->x + (i&1)*16;
-     int mvy= pmv[i]->y + (i>>1)*16;
+     /* predict and decode motion vector (3) */
+     pmv[2] = &motion[(x / 8) + 2];
+     pmv[3] = &motion[(x / 8) + 3];
  
-     ///XXX /FIXME clipping or padding?
-     if(y + (mvy >> 1)<0)
-        mvy= 0;
-     if(x + (mvx >> 1)<0)
-        mvx= 0;
+     result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
  
-     src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
-     dst = current;
+     if (result != 0)
+         return result;
  
-     s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
+     /* form predictions */
+     for (i = 0; i < 4; i++) {
+         int mvx = pmv[i]->x + (i  & 1) * 16;
+         int mvy = pmv[i]->y + (i >> 1) * 16;
  
-     /* select next block */
-     if (i & 1) {
-       current  += 8*(pitch - 1);
-     } else {
-       current  += 8;
-     }
-   }
+         // FIXME: clipping or padding?
+         if (y + (mvy >> 1) < 0)
+             mvy = 0;
+         if (x + (mvx >> 1) < 0)
+             mvx = 0;
  
-   return 0;
- }
+         src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
+         dst = current;
  
- static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
-                         uint8_t *current, uint8_t *previous, int pitch,
-                         svq1_pmv *motion, int x, int y) {
-   uint32_t block_type;
-   int      result = 0;
-   /* get block type */
-   block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
-   /* reset motion vectors */
-   if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
-     motion[0].x                 =
-     motion[0].y                 =
-     motion[(x / 8) + 2].x =
-     motion[(x / 8) + 2].y =
-     motion[(x / 8) + 3].x =
-     motion[(x / 8) + 3].y = 0;
-   }
-   switch (block_type) {
-   case SVQ1_BLOCK_SKIP:
-     svq1_skip_block (current, previous, pitch, x, y);
-     break;
-   case SVQ1_BLOCK_INTER:
-     result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
+         s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
  
-     if (result != 0)
-     {
-       av_dlog(s->avctx, "Error in svq1_motion_inter_block %i\n", result);
-       break;
+         /* select next block */
+         if (i & 1)
+             current += 8 * (pitch - 1);
+         else
+             current += 8;
      }
-     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
-     break;
  
-   case SVQ1_BLOCK_INTER_4V:
-     result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
+     return 0;
+ }
  
-     if (result != 0)
-     {
-       av_dlog(s->avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
-       break;
+ static int svq1_decode_delta_block(MpegEncContext *s, GetBitContext *bitbuf,
+                                    uint8_t *current, uint8_t *previous,
+                                    int pitch, svq1_pmv *motion, int x, int y)
+ {
+     uint32_t block_type;
+     int result = 0;
+     /* get block type */
+     block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
+     /* reset motion vectors */
+     if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
+         motion[0].x         =
+         motion[0].y         =
+         motion[x / 8 + 2].x =
+         motion[x / 8 + 2].y =
+         motion[x / 8 + 3].x =
+         motion[x / 8 + 3].y = 0;
      }
-     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
-     break;
  
-   case SVQ1_BLOCK_INTRA:
-     result = svq1_decode_block_intra (bitbuf, current, pitch);
-     break;
-   }
+     switch (block_type) {
+     case SVQ1_BLOCK_SKIP:
+         svq1_skip_block(current, previous, pitch, x, y);
+         break;
  
-   return result;
- }
+     case SVQ1_BLOCK_INTER:
+         result = svq1_motion_inter_block(s, bitbuf, current, previous,
+                                          pitch, motion, x, y);
  
- static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
-   uint8_t seed;
-   int     i;
+         if (result != 0) {
+             av_dlog(s->avctx, "Error in svq1_motion_inter_block %i\n", result);
+             break;
+         }
+         result = svq1_decode_block_non_intra(bitbuf, current, pitch);
+         break;
  
-   out[0] = get_bits (bitbuf, 8);
+     case SVQ1_BLOCK_INTER_4V:
+         result = svq1_motion_inter_4v_block(s, bitbuf, current, previous,
+                                             pitch, motion, x, y);
  
-   seed = string_table[out[0]];
+         if (result != 0) {
+             av_dlog(s->avctx,
+                     "Error in svq1_motion_inter_4v_block %i\n", result);
+             break;
+         }
+         result = svq1_decode_block_non_intra(bitbuf, current, pitch);
+         break;
  
-   for (i=1; i <= out[0]; i++) {
-     out[i] = get_bits (bitbuf, 8) ^ seed;
-     seed   = string_table[out[i] ^ seed];
-   }
+     case SVQ1_BLOCK_INTRA:
+         result = svq1_decode_block_intra(bitbuf, current, pitch);
+         break;
+     }
+     return result;
  }
  
- static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
-   int frame_size_code;
+ static void svq1_parse_string(GetBitContext *bitbuf, uint8_t *out)
+ {
+     uint8_t seed;
+     int i;
+     out[0] = get_bits(bitbuf, 8);
+     seed   = string_table[out[0]];
  
-   skip_bits(bitbuf, 8); /* temporal_reference */
+     for (i = 1; i <= out[0]; i++) {
+         out[i] = get_bits(bitbuf, 8) ^ seed;
+         seed   = string_table[out[i] ^ seed];
+     }
+ }
  
-   /* frame type */
-   s->pict_type= get_bits (bitbuf, 2)+1;
-   if(s->pict_type==4)
-       return -1;
+ static int svq1_decode_frame_header(GetBitContext *bitbuf, MpegEncContext *s)
+ {
+     int frame_size_code;
  
-   if (s->pict_type == AV_PICTURE_TYPE_I) {
+     skip_bits(bitbuf, 8); /* temporal_reference */
  
-     /* unknown fields */
-     if (s->f_code == 0x50 || s->f_code == 0x60) {
-       int csum = get_bits (bitbuf, 16);
+     /* frame type */
+     s->pict_type = get_bits(bitbuf, 2) + 1;
+     if (s->pict_type == 4)
+         return -1;
  
-       csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
+     if (s->pict_type == AV_PICTURE_TYPE_I) {
+         /* unknown fields */
+         if (s->f_code == 0x50 || s->f_code == 0x60) {
+             int csum = get_bits(bitbuf, 16);
  
-       av_dlog(s->avctx, "%s checksum (%02x) for packet data\n",
-               (csum == 0) ? "correct" : "incorrect", csum);
-     }
+             csum = ff_svq1_packet_checksum(bitbuf->buffer,
+                                            bitbuf->size_in_bits >> 3,
+                                            csum);
  
-     if ((s->f_code ^ 0x10) >= 0x50) {
-       uint8_t msg[256];
+             av_dlog(s->avctx, "%s checksum (%02x) for packet data\n",
+                     (csum == 0) ? "correct" : "incorrect", csum);
+         }
  
-       svq1_parse_string (bitbuf, msg);
+         if ((s->f_code ^ 0x10) >= 0x50) {
+             uint8_t msg[256];
  
-       av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
-     }
+             svq1_parse_string(bitbuf, msg);
  
-     skip_bits (bitbuf, 2);
-     skip_bits (bitbuf, 2);
-     skip_bits1 (bitbuf);
 -            av_log(s->avctx, AV_LOG_INFO,
++            av_log(s->avctx, AV_LOG_ERROR,
+                    "embedded message: \"%s\"\n", (char *)msg);
+         }
  
-     /* load frame size */
-     frame_size_code = get_bits (bitbuf, 3);
+         skip_bits(bitbuf, 2);
+         skip_bits(bitbuf, 2);
+         skip_bits1(bitbuf);
  
-     if (frame_size_code == 7) {
-       /* load width, height (12 bits each) */
-       s->width = get_bits (bitbuf, 12);
-       s->height = get_bits (bitbuf, 12);
+         /* load frame size */
+         frame_size_code = get_bits(bitbuf, 3);
  
-       if (!s->width || !s->height)
-         return -1;
-     } else {
-       /* get width, height from table */
-       s->width = ff_svq1_frame_size_table[frame_size_code].width;
-       s->height = ff_svq1_frame_size_table[frame_size_code].height;
+         if (frame_size_code == 7) {
+             /* load width, height (12 bits each) */
+             s->width  = get_bits(bitbuf, 12);
+             s->height = get_bits(bitbuf, 12);
+             if (!s->width || !s->height)
+                 return -1;
+         } else {
+             /* get width, height from table */
+             s->width  = ff_svq1_frame_size_table[frame_size_code].width;
+             s->height = ff_svq1_frame_size_table[frame_size_code].height;
+         }
      }
-   }
  
-   /* unknown fields */
-   if (get_bits1 (bitbuf) == 1) {
-     skip_bits1 (bitbuf);       /* use packet checksum if (1) */
-     skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
+     /* unknown fields */
+     if (get_bits1(bitbuf) == 1) {
+         skip_bits1(bitbuf);    /* use packet checksum if (1) */
+         skip_bits1(bitbuf);    /* component checksums after image data if (1) */
  
-     if (get_bits (bitbuf, 2) != 0)
-       return -1;
-   }
+         if (get_bits(bitbuf, 2) != 0)
+             return -1;
+     }
  
-   if (get_bits1 (bitbuf) == 1) {
-     skip_bits1 (bitbuf);
-     skip_bits (bitbuf, 4);
-     skip_bits1 (bitbuf);
-     skip_bits (bitbuf, 2);
+     if (get_bits1(bitbuf) == 1) {
+         skip_bits1(bitbuf);
+         skip_bits(bitbuf, 4);
+         skip_bits1(bitbuf);
+         skip_bits(bitbuf, 2);
  
-     while (get_bits1 (bitbuf) == 1) {
-       skip_bits (bitbuf, 8);
+         while (get_bits1(bitbuf) == 1)
+             skip_bits(bitbuf, 8);
      }
-   }
  
-   return 0;
+     return 0;
  }
  
- static int svq1_decode_frame(AVCodecContext *avctx,
-                              void *data, int *data_size,
-                              AVPacket *avpkt)
+ static int svq1_decode_frame(AVCodecContext *avctx, void *data,
+                              int *data_size, AVPacket *avpkt)
  {
-   const uint8_t *buf = avpkt->data;
-   int buf_size = avpkt->size;
-   MpegEncContext *s=avctx->priv_data;
-   uint8_t        *current, *previous;
-   int             result, i, x, y, width, height;
-   AVFrame *pict = data;
-   svq1_pmv *pmv;
+     const uint8_t *buf = avpkt->data;
+     int buf_size       = avpkt->size;
+     MpegEncContext *s  = avctx->priv_data;
+     uint8_t *current, *previous;
+     int result, i, x, y, width, height;
+     AVFrame *pict = data;
+     svq1_pmv *pmv;
  
-   /* initialize bit buffer */
-   init_get_bits(&s->gb,buf,buf_size*8);
+     /* initialize bit buffer */
+     init_get_bits(&s->gb, buf, buf_size * 8);
  
-   /* decode frame header */
-   s->f_code = get_bits (&s->gb, 22);
+     /* decode frame header */
+     s->f_code = get_bits(&s->gb, 22);
  
-   if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
-     return -1;
+     if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
+         return -1;
  
-   /* swap some header bytes (why?) */
-   if (s->f_code != 0x20) {
-     uint32_t *src = (uint32_t *) (buf + 4);
+     /* swap some header bytes (why?) */
+     if (s->f_code != 0x20) {
+         uint32_t *src = (uint32_t *)(buf + 4);
  
-     if (buf_size < 36)
-         return AVERROR_INVALIDDATA;
++        if (buf_size < 36)
++            return AVERROR_INVALIDDATA;
 +
-     for (i=0; i < 4; i++) {
-       src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
+         for (i = 0; i < 4; i++)
+             src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
      }
-   }
  
-   result = svq1_decode_frame_header (&s->gb, s);
+     result = svq1_decode_frame_header(&s->gb, s);
  
-   if (result != 0)
-   {
-     av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n",result);
-     return result;
-   }
-   avcodec_set_dimensions(avctx, s->width, s->height);
-   //FIXME this avoids some confusion for "B frames" without 2 references
-   //this should be removed after libavcodec can handle more flexible picture types & ordering
-   if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
-   if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
-      ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
-      || avctx->skip_frame >= AVDISCARD_ALL)
-       return buf_size;
-   if(ff_MPV_frame_start(s, avctx) < 0)
-       return -1;
-   pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
-   if (!pmv)
-       return -1;
-   /* decode y, u and v components */
-   for (i=0; i < 3; i++) {
-     int linesize;
-     if (i == 0) {
-       width  = FFALIGN(s->width, 16);
-       height = FFALIGN(s->height, 16);
-       linesize= s->linesize;
-     } else {
-       if(s->flags&CODEC_FLAG_GRAY) break;
-       width  = FFALIGN(s->width/4, 16);
-       height = FFALIGN(s->height/4, 16);
-       linesize= s->uvlinesize;
+     if (result != 0) {
+         av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n", result);
+         return result;
      }
+     avcodec_set_dimensions(avctx, s->width, s->height);
+     /* FIXME: This avoids some confusion for "B frames" without 2 references.
+      * This should be removed after libavcodec can handle more flexible
+      * picture types & ordering */
+     if (s->pict_type == AV_PICTURE_TYPE_B && s->last_picture_ptr == NULL)
+         return buf_size;
+     if ((avctx->skip_frame >= AVDISCARD_NONREF &&
+          s->pict_type == AV_PICTURE_TYPE_B)    ||
+         (avctx->skip_frame >= AVDISCARD_NONKEY &&
+          s->pict_type != AV_PICTURE_TYPE_I)    ||
+         avctx->skip_frame >= AVDISCARD_ALL)
+         return buf_size;
+     if (ff_MPV_frame_start(s, avctx) < 0)
+         return -1;
  
-     current = s->current_picture.f.data[i];
-     if(s->pict_type==AV_PICTURE_TYPE_B){
-         previous = s->next_picture.f.data[i];
-     }else{
-         previous = s->last_picture.f.data[i];
-     }
+     pmv = av_malloc((FFALIGN(s->width, 16) / 8 + 3) * sizeof(*pmv));
+     if (!pmv)
+         return -1;
  
-     if (s->pict_type == AV_PICTURE_TYPE_I) {
-       /* keyframe */
-       for (y=0; y < height; y+=16) {
-         for (x=0; x < width; x+=16) {
-           result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
-           if (result != 0)
-           {
-             av_log(s->avctx, AV_LOG_ERROR, "Error in svq1_decode_block %i (keyframe)\n",result);
-             goto err;
-           }
-         }
-         current += 16*linesize;
-       }
-     } else {
-       /* delta frame */
-       memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
-       for (y=0; y < height; y+=16) {
-         for (x=0; x < width; x+=16) {
-           result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
-                                             linesize, pmv, x, y);
-           if (result != 0)
-           {
-             av_dlog(s->avctx, "Error in svq1_decode_delta_block %i\n",result);
-             goto err;
-           }
+     /* decode y, u and v components */
+     for (i = 0; i < 3; i++) {
+         int linesize;
+         if (i == 0) {
+             width    = FFALIGN(s->width,  16);
+             height   = FFALIGN(s->height, 16);
+             linesize = s->linesize;
+         } else {
+             if (s->flags & CODEC_FLAG_GRAY)
+                 break;
+             width    = FFALIGN(s->width  / 4, 16);
+             height   = FFALIGN(s->height / 4, 16);
+             linesize = s->uvlinesize;
          }
  
-         pmv[0].x =
-         pmv[0].y = 0;
-         current += 16*linesize;
-       }
+         current = s->current_picture.f.data[i];
+         if (s->pict_type == AV_PICTURE_TYPE_B)
+             previous = s->next_picture.f.data[i];
+         else
+             previous = s->last_picture.f.data[i];
+         if (s->pict_type == AV_PICTURE_TYPE_I) {
+             /* keyframe */
+             for (y = 0; y < height; y += 16) {
+                 for (x = 0; x < width; x += 16) {
+                     result = svq1_decode_block_intra(&s->gb, &current[x],
+                                                      linesize);
+                     if (result != 0) {
+                         av_log(s->avctx, AV_LOG_INFO,
+                                "Error in svq1_decode_block %i (keyframe)\n",
+                                result);
+                         goto err;
+                     }
+                 }
+                 current += 16 * linesize;
+             }
+         } else {
+             /* delta frame */
+             memset(pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
+             for (y = 0; y < height; y += 16) {
+                 for (x = 0; x < width; x += 16) {
+                     result = svq1_decode_delta_block(s, &s->gb, &current[x],
+                                                      previous, linesize,
+                                                      pmv, x, y);
+                     if (result != 0) {
+                         av_dlog(s->avctx,
+                                 "Error in svq1_decode_delta_block %i\n",
+                                 result);
+                         goto err;
+                     }
+                 }
+                 pmv[0].x     =
+                     pmv[0].y = 0;
+                 current += 16 * linesize;
+             }
+         }
      }
-   }
  
-   *pict = s->current_picture.f;
+     *pict = s->current_picture.f;
  
+     ff_MPV_frame_end(s);
  
-   ff_MPV_frame_end(s);
+     *data_size = sizeof(AVFrame);
+     result     = buf_size;
  
-   *data_size=sizeof(AVFrame);
-   result = buf_size;
  err:
-   av_free(pmv);
-   return result;
+     av_free(pmv);
+     return result;
  }
  
  static av_cold int svq1_decode_init(AVCodecContext *avctx)
  #include "mpegvideo.h"
  #include "h263.h"
  #include "internal.h"
 +#include "libavutil/avassert.h"
  #include "svq1.h"
  #include "svq1enc_cb.h"
  
 -#undef NDEBUG
 -#include <assert.h>
  
  typedef struct SVQ1Context {
-     MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to make the motion estimation eventually independent of MpegEncContext, so this will be removed then (FIXME/XXX)
+     /* FIXME: Needed for motion estimation, should not be used for anything
+      * else, the idea is to make the motion estimation eventually independent
+      * of MpegEncContext, so this will be removed then. */
+     MpegEncContext m;
      AVCodecContext *avctx;
      DSPContext dsp;
      AVFrame picture;
@@@ -93,14 -94,14 +93,14 @@@ static void svq1_write_header(SVQ1Conte
          /* output 5 unknown bits (2 + 2 + 1) */
          put_bits(&s->pb, 5, 2); /* 2 needed by quicktime decoder */
  
-         i= ff_match_2uint16((void*)ff_svq1_frame_size_table, FF_ARRAY_ELEMS(ff_svq1_frame_size_table), s->frame_width, s->frame_height);
 -        i = ff_match_2uint16(ff_svq1_frame_size_table,
++        i = ff_match_2uint16((void*)ff_svq1_frame_size_table,
+                              FF_ARRAY_ELEMS(ff_svq1_frame_size_table),
+                              s->frame_width, s->frame_height);
          put_bits(&s->pb, 3, i);
  
-         if (i == 7)
-         {
-                 put_bits(&s->pb, 12, s->frame_width);
-                 put_bits(&s->pb, 12, s->frame_height);
+         if (i == 7) {
+             put_bits(&s->pb, 12, s->frame_width);
+             put_bits(&s->pb, 12, s->frame_height);
          }
      }
  
@@@ -154,50 -157,49 +156,49 @@@ static int encode_block(SVQ1Context *s
          }
      }
  
-     best_count=0;
-     best_score -= (int)(((unsigned)block_sum[0]*block_sum[0])>>(level+3));
-     best_mean= (block_sum[0] + (size>>1)) >> (level+3);
+     best_count  = 0;
+     best_score -= (int)((unsigned)block_sum[0] * block_sum[0] >> (level + 3));
+     best_mean   = block_sum[0] + (size >> 1) >> (level + 3);
  
-     if(level<4){
-         for(count=1; count<7; count++){
-             int best_vector_score= INT_MAX;
-             int best_vector_sum=-999, best_vector_mean=-999;
-             const int stage= count-1;
+     if (level < 4) {
+         for (count = 1; count < 7; count++) {
+             int best_vector_score = INT_MAX;
+             int best_vector_sum   = -999, best_vector_mean = -999;
+             const int stage       = count - 1;
              const int8_t *vector;
  
-             for(i=0; i<16; i++){
-                 int sum= codebook_sum[stage*16 + i];
+             for (i = 0; i < 16; i++) {
+                 int sum = codebook_sum[stage * 16 + i];
                  int sqr, diff, score;
  
-                 vector = codebook + stage*size*16 + i*size;
-                 sqr = s->dsp.ssd_int8_vs_int16(vector, block[stage], size);
-                 diff= block_sum[stage] - sum;
-                 score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow
-                 if(score < best_vector_score){
-                     int mean= (diff + (size>>1)) >> (level+3);
-                     av_assert2(mean >-300 && mean<300);
-                     mean= av_clip(mean, intra?0:-256, 255);
-                     best_vector_score= score;
-                     best_vector[stage]= i;
-                     best_vector_sum= sum;
-                     best_vector_mean= mean;
+                 vector = codebook + stage * size * 16 + i * size;
+                 sqr    = s->dsp.ssd_int8_vs_int16(vector, block[stage], size);
+                 diff   = block_sum[stage] - sum;
+                 score  = sqr - (diff * (int64_t)diff >> (level + 3)); // FIXME: 64bit slooow
+                 if (score < best_vector_score) {
+                     int mean = diff + (size >> 1) >> (level + 3);
 -                    assert(mean > -300 && mean < 300);
++                    av_assert2(mean > -300 && mean < 300);
+                     mean               = av_clip(mean, intra ? 0 : -256, 255);
+                     best_vector_score  = score;
+                     best_vector[stage] = i;
+                     best_vector_sum    = sum;
+                     best_vector_mean   = mean;
                  }
              }
 -            assert(best_vector_mean != -999);
 +            av_assert0(best_vector_mean != -999);
-             vector= codebook + stage*size*16 + best_vector[stage]*size;
-             for(j=0; j<size; j++){
-                 block[stage+1][j] = block[stage][j] - vector[j];
-             }
-             block_sum[stage+1]= block_sum[stage] - best_vector_sum;
-             best_vector_score +=
-                 lambda*(+ 1 + 4*count
-                         + multistage_vlc[1+count][1]
-                         + mean_vlc[best_vector_mean][1]);
-             if(best_vector_score < best_score){
-                 best_score= best_vector_score;
-                 best_count= count;
-                 best_mean= best_vector_mean;
+             vector = codebook + stage * size * 16 + best_vector[stage] * size;
+             for (j = 0; j < size; j++)
+                 block[stage + 1][j] = block[stage][j] - vector[j];
+             block_sum[stage + 1] = block_sum[stage] - best_vector_sum;
+             best_vector_score   += lambda *
+                                    (+1 + 4 * count +
+                                     multistage_vlc[1 + count][1]
+                                     + mean_vlc[best_vector_mean][1]);
+             if (best_vector_score < best_score) {
+                 best_score = best_vector_score;
+                 best_count = count;
+                 best_mean  = best_vector_mean;
              }
          }
      }
      if (level > 0)
          put_bits(&s->reorder_pb[level], 1, split);
  
-     if(!split){
-         av_assert1((best_mean >= 0 && best_mean<256) || !intra);
-         av_assert1(best_mean >= -256 && best_mean<256);
-         av_assert1(best_count >=0 && best_count<7);
-         av_assert1(level<4 || best_count==0);
+     if (!split) {
 -        assert(best_mean >= 0 && best_mean < 256 || !intra);
 -        assert(best_mean >= -256 && best_mean < 256);
 -        assert(best_count >= 0 && best_count < 7);
 -        assert(level < 4 || best_count == 0);
++        av_assert1(best_mean >= 0 && best_mean < 256 || !intra);
++        av_assert1(best_mean >= -256 && best_mean < 256);
++        av_assert1(best_count >= 0 && best_count < 7);
++        av_assert1(level < 4 || best_count == 0);
  
          /* output the encoding */
          put_bits(&s->reorder_pb[level],
-             multistage_vlc[1 + best_count][1],
-             multistage_vlc[1 + best_count][0]);
+                  multistage_vlc[1 + best_count][1],
+                  multistage_vlc[1 + best_count][0]);
          put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
-             mean_vlc[best_mean][0]);
+                  mean_vlc[best_mean][0]);
  
-         for (i = 0; i < best_count; i++){
-             av_assert2(best_vector[i]>=0 && best_vector[i]<16);
+         for (i = 0; i < best_count; i++) {
 -            assert(best_vector[i] >= 0 && best_vector[i] < 16);
++            av_assert2(best_vector[i] >= 0 && best_vector[i] < 16);
              put_bits(&s->reorder_pb[level], 4, best_vector[i]);
          }
  
@@@ -408,34 -431,38 +430,38 @@@ static int svq1_encode_plane(SVQ1Contex
  
                      put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
  
-                     s->m.pb= s->reorder_pb[5];
-                     mx= motion_ptr[0];
-                     my= motion_ptr[1];
-                     av_assert1(mx>=-32 && mx<=31);
-                     av_assert1(my>=-32 && my<=31);
-                     av_assert1(pred_x>=-32 && pred_x<=31);
-                     av_assert1(pred_y>=-32 && pred_y<=31);
+                     s->m.pb = s->reorder_pb[5];
+                     mx      = motion_ptr[0];
+                     my      = motion_ptr[1];
 -                    assert(mx     >= -32 && mx     <= 31);
 -                    assert(my     >= -32 && my     <= 31);
 -                    assert(pred_x >= -32 && pred_x <= 31);
 -                    assert(pred_y >= -32 && pred_y <= 31);
++                    av_assert1(mx     >= -32 && mx     <= 31);
++                    av_assert1(my     >= -32 && my     <= 31);
++                    av_assert1(pred_x >= -32 && pred_x <= 31);
++                    av_assert1(pred_y >= -32 && pred_y <= 31);
                      ff_h263_encode_motion(&s->m, mx - pred_x, 1);
                      ff_h263_encode_motion(&s->m, my - pred_y, 1);
-                     s->reorder_pb[5]= s->m.pb;
-                     score[1] += lambda*put_bits_count(&s->reorder_pb[5]);
-                     dxy= (mx&1) + 2*(my&1);
-                     s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16);
-                     score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0);
-                     best= score[1] <= score[0];
-                     vlc= ff_svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
-                     score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16);
-                     score[2]+= vlc[1]*lambda;
-                     if(score[2] < score[best] && mx==0 && my==0){
-                         best=2;
+                     s->reorder_pb[5] = s->m.pb;
+                     score[1]        += lambda * put_bits_count(&s->reorder_pb[5]);
+                     dxy = (mx & 1) + 2 * (my & 1);
+                     s->dsp.put_pixels_tab[0][dxy](temp + 16,
+                                                   ref + (mx >> 1) +
+                                                   stride * (my >> 1),
+                                                   stride, 16);
+                     score[1] += encode_block(s, src + 16 * x, temp + 16,
+                                              decoded, stride, 5, 64, lambda, 0);
+                     best      = score[1] <= score[0];
+                     vlc       = ff_svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
+                     score[2]  = s->dsp.sse[0](NULL, src + 16 * x, ref,
+                                               stride, 16);
+                     score[2] += vlc[1] * lambda;
+                     if (score[2] < score[best] && mx == 0 && my == 0) {
+                         best = 2;
                          s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
-                         for(i=0; i<6; i++){
-                             count[2][i]=0;
-                         }
+                         for (i = 0; i < 6; i++)
+                             count[2][i] = 0;
                          put_bits(&s->pb, vlc[1], vlc[0]);
                      }
                  }
@@@ -505,10 -538,14 +537,11 @@@ static int svq1_encode_frame(AVCodecCon
      AVFrame temp;
      int i, ret;
  
-     if ((ret = ff_alloc_packet2(avctx, pkt, s->y_block_width*s->y_block_height*MAX_MB_BYTES*3 + FF_MIN_BUFFER_SIZE) < 0))
 -    if (!pkt->data &&
 -        (ret = av_new_packet(pkt, s->y_block_width * s->y_block_height *
 -                             MAX_MB_BYTES * 3 + FF_MIN_BUFFER_SIZE) < 0)) {
 -        av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
++    if ((ret = ff_alloc_packet2(avctx, pkt, s->y_block_width * s->y_block_height *
++                             MAX_MB_BYTES*3 + FF_MIN_BUFFER_SIZE) < 0))
          return ret;
 -    }
  
-     if(avctx->pix_fmt != AV_PIX_FMT_YUV410P){
+     if (avctx->pix_fmt != AV_PIX_FMT_YUV410P) {
          av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
          return -1;
      }
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -30,8 -30,8 +30,8 @@@
  #include "libavutil/avutil.h"
  
  #define LIBAVFORMAT_VERSION_MAJOR 54
- #define LIBAVFORMAT_VERSION_MINOR 31
 -#define LIBAVFORMAT_VERSION_MINOR 18
 -#define LIBAVFORMAT_VERSION_MICRO  0
++#define LIBAVFORMAT_VERSION_MINOR 32
 +#define LIBAVFORMAT_VERSION_MICRO 100
  
  #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
                                                 LIBAVFORMAT_VERSION_MINOR, \
@@@ -722,9 -682,9 +722,9 @@@ int main(void
          for (i = 0; i < FF_ARRAY_ELEMS(rates); i++) {
              int ret;
              AVRational q = (AVRational){0, 0};
 -            ret = av_parse_video_rate(&q, rates[i]),
 +            ret = av_parse_video_rate(&q, rates[i]);
-             printf("'%s' -> %d/%d%s\n",
-                    rates[i], q.num, q.den, ret ? " error" : "");
+             printf("'%s' -> %d/%d %s\n",
+                    rates[i], q.num, q.den, ret ? "ERROR" : "OK");
          }
      }
  
@@@ -1,36 -1,32 +1,36 @@@
  Testing av_parse_video_rate()
- '-inf' -> -1/0 error
- 'inf' -> 1/0 error
- 'nan' -> 0/0 error
- '123/0' -> 1/0 error
- '-123 / 0' -> -1/0 error
- '' -> 0/0 error
- '/' -> 0/0 error
- ' 123  /  321' -> 41/107
- 'foo/foo' -> 0/0 error
- 'foo/1' -> 0/0 error
- '1/foo' -> 1/0 error
- '0/0' -> 0/0 error
- '/0' -> 0/0 error
- '1/' -> 1/0 error
- '1' -> 1/1
- '0' -> 0/1 error
- '-123/123' -> -1/1 error
- '-foo' -> 0/0 error
- '123.23' -> 12323/100
- '.23' -> 23/100
- '-.23' -> -23/100 error
- '-0.234' -> -117/500 error
- '-0.0000001' -> 0/1 error
- '  21332.2324   ' -> 917286/43
- ' -21332.2324   ' -> -917286/43 error
+ '-inf' -> -1/0 ERROR
+ 'inf' -> 1/0 ERROR
+ 'nan' -> 0/0 ERROR
+ '123/0' -> 1/0 ERROR
+ '-123 / 0' -> -1/0 ERROR
+ '' -> 0/0 ERROR
+ '/' -> 0/0 ERROR
+ ' 123  /  321' -> 41/107 OK
+ 'foo/foo' -> 0/0 ERROR
+ 'foo/1' -> 0/0 ERROR
 -'1/foo' -> 0/0 ERROR
++'1/foo' -> 1/0 ERROR
+ '0/0' -> 0/0 ERROR
+ '/0' -> 0/0 ERROR
 -'1/' -> 0/0 ERROR
++'1/' -> 1/0 ERROR
+ '1' -> 1/1 OK
+ '0' -> 0/1 ERROR
+ '-123/123' -> -1/1 ERROR
+ '-foo' -> 0/0 ERROR
+ '123.23' -> 12323/100 OK
+ '.23' -> 23/100 OK
+ '-.23' -> -23/100 ERROR
+ '-0.234' -> -117/500 ERROR
+ '-0.0000001' -> 0/1 ERROR
+ '  21332.2324   ' -> 917286/43 OK
+ ' -21332.2324   ' -> -917286/43 ERROR
  
  Testing av_parse_color()
 +bikeshed -> R(80) G(64) B(140) A(59)
 +RaNdOm -> R(185) G(88) B(148) A(94)
 +foo -> error
  red -> R(255) G(0) B(0) A(255)
 +Red  -> error
  RED -> R(255) G(0) B(0) A(255)
  Violet -> R(238) G(130) B(238) A(255)
  Yellow -> R(255) G(255) B(0) A(255)