@@ -3783,7 +3783,7 @@ static void opt_output_file(void *optctx, const char *filename)

     }

     if (!(oc->oformat->flags & AVFMT_NOFILE)) {

-        /* test if it already exists to avoid loosing precious files */

+        /* test if it already exists to avoid losing precious files */

         assert_file_overwrite(filename);

         /* open the file */

@@ -91,7 +91,7 @@ int opt_timelimit(const char *opt, const char *arg);

  * parsed or the corresponding value is invalid.

  *

  * @param context the context of the value to be set (e.g. the

- * corresponding commandline option name)

+ * corresponding command line option name)

  * @param numstr the string to be parsed

  * @param type the type (OPT_INT64 or OPT_FLOAT) as which the

  * string should be parsed

@@ -106,7 +106,7 @@ double parse_number_or_die(const char *context, const char *numstr, int type, do

  * the string cannot be correctly parsed.

  *

  * @param context the context of the value to be set (e.g. the

- * corresponding commandline option name)

+ * corresponding command line option name)

  * @param timestr the string to be parsed

  * @param is_duration a flag which tells how to interpret timestr, if

  * not zero timestr is interpreted as a duration, otherwise as a

@@ -189,7 +189,7 @@ void parse_options(void *optctx, int argc, char **argv, const OptionDef *options

 int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options);

 /**

- * Find the '-loglevel' option in the commandline args and apply it.

+ * Find the '-loglevel' option in the command line args and apply it.

  */

 void parse_loglevel(int argc, char **argv, const OptionDef *options);

@@ -29,7 +29,7 @@ rates and resize video on the fly with a high quality polyphase filter.

 avconv reads from an arbitrary number of input "files" (which can be regular

 files, pipes, network streams, grabbing devices, etc.), specified by the

 @code{-i} option, and writes to an arbitrary number of output "files", which are

-specified by a plain output filename. Anything found on the commandline which

+specified by a plain output filename. Anything found on the command line which

 cannot be interpreted as an option is considered to be an output filename.

 Each input or output file can in principle contain any number of streams of

@@ -147,7 +147,7 @@ that only captures in stereo and also requires that one channel be flipped.

 If you are one of these people, then export 'AUDIO_FLIP_LEFT=1' before

 starting ffmpeg.

-@subsection The audio and video loose sync after a while.

+@subsection The audio and video lose sync after a while.

 Yes, they do.

@@ -155,8 +155,8 @@ be seekable, so they will fail with the pipe output protocol.

 Real-Time Messaging Protocol.

-The Real-Time Messaging Protocol (RTMP) is used for streaming

-multimedia content across a TCP/IP network.

+The Real-Time Messaging Protocol (RTMP) is used for streaming multimedia

+content across a TCP/IP network.

 The required syntax is:

 @example

@@ -18,7 +18,7 @@ essential that changes to their codebase are publicly visible, clean and

 easy reviewable that again leads us to:

 * use of a revision control system like git

 * separation of cosmetic from non-cosmetic changes (this is almost entirely

-  ignored by mentors and students in soc 2006 which might lead to a suprise

+  ignored by mentors and students in soc 2006 which might lead to a surprise

   when the code will be reviewed at the end before a possible inclusion in

   FFmpeg, individual changes were generally not reviewable due to cosmetics).

 * frequent commits, so that comments can be provided early

@@ -4162,7 +4162,7 @@ static void opt_output_file(void *optctx, const char *filename)

     }

     if (!(oc->oformat->flags & AVFMT_NOFILE)) {

-        /* test if it already exists to avoid loosing precious files */

+        /* test if it already exists to avoid losing precious files */

         assert_file_overwrite(filename);

         /* open the file */

@@ -2468,8 +2468,6 @@ static int read_thread(void *arg)

     if(genpts)

         ic->flags |= AVFMT_FLAG_GENPTS;

-    av_dict_set(&codec_opts, "request_channels", "2", 0);

-

     opts = setup_find_stream_info_opts(ic, codec_opts);

     orig_nb_streams = ic->nb_streams;

@@ -475,7 +475,7 @@ static void start_children(FFStream *feed)

                     slash++;

                 strcpy(slash, "ffmpeg");

-                http_log("Launch commandline: ");

+                http_log("Launch command line: ");

                 http_log("%s ", pathname);

                 for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)

                     http_log("%s ", feed->child_argv[i]);

@@ -1348,7 +1348,7 @@ typedef struct AVCodecContext {

      * Some codecs need additional format info. It is stored here.

      * If any muxer uses this then ALL demuxers/parsers AND encoders for the

      * specific codec MUST set it correctly otherwise stream copy breaks.

-     * In general use of this field by muxers is not recommanded.

+     * In general use of this field by muxers is not recommended.

      * - encoding: Set by libavcodec.

      * - decoding: Set by libavcodec. (FIXME: Is this OK?)

      */

@@ -3541,7 +3541,7 @@ typedef struct ReSampleContext ReSampleContext;

  * @param linear           if 1 then the used FIR filter will be linearly interpolated

                            between the 2 closest, if 0 the closest will be used

  * @param cutoff           cutoff frequency, 1.0 corresponds to half the output sampling rate

- * @return allocated ReSampleContext, NULL if error occured

+ * @return allocated ReSampleContext, NULL if error occurred

  */

 ReSampleContext *av_audio_resample_init(int output_channels, int input_channels,

                                         int output_rate, int input_rate,

@@ -35,7 +35,7 @@

 #include "dct.h"

 #include "rdft.h"

 #include "fmtconvert.h"

-#include "libavutil/intfloat_readwrite.h"

+#include "libavutil/intfloat.h"

 extern const uint16_t ff_wma_critical_freqs[25];

@@ -193,8 +193,8 @@ static int decode_block(BinkAudioContext *s, int16_t *out, int use_dct)

         if (s->version_b) {

             if (get_bits_left(gb) < 64)

                 return AVERROR_INVALIDDATA;

-            coeffs[0] = av_int2flt(get_bits(gb, 32)) * s->root;

-            coeffs[1] = av_int2flt(get_bits(gb, 32)) * s->root;

+            coeffs[0] = av_int2float(get_bits_long(gb, 32)) * s->root;

+            coeffs[1] = av_int2float(get_bits_long(gb, 32)) * s->root;

         } else {

             if (get_bits_left(gb) < 58)

                 return AVERROR_INVALIDDATA;

@@ -103,7 +103,7 @@ static int alloc_table(VLC *vlc, int size, int use_static)

     vlc->table_size += size;

     if (vlc->table_size > vlc->table_allocated) {

         if(use_static)

-            abort(); //cant do anything, init_vlc() is used with too little memory

+            abort(); // cannot do anything, init_vlc() is used with too little memory

         vlc->table_allocated += (1 << vlc->bits);

         vlc->table = av_realloc_f(vlc->table,

                                   vlc->table_allocated, sizeof(VLC_TYPE) * 2);

@@ -157,7 +157,7 @@ static int tgv_decode_inter(TgvContext * s, const uint8_t *buf, const uint8_t *b

     vector_bits       = AV_RL16(&buf[6]);

     buf += 12;

-    /* allocate codebook buffers as neccessary */

+    /* allocate codebook buffers as necessary */

     if (num_mvs > s->num_mvs) {

         s->mv_codebook = av_realloc(s->mv_codebook, num_mvs*2*sizeof(int));

         s->num_mvs = num_mvs;

@@ -293,7 +293,7 @@ static int tgv_decode_frame(AVCodecContext *avctx,

         s->frame.buffer_hints = FF_BUFFER_HINTS_VALID;

         s->frame.linesize[0] = s->width;

-        /* allocate additional 12 bytes to accomodate av_memcpy_backptr() OUTBUF_PADDED optimisation */

+        /* allocate additional 12 bytes to accommodate av_memcpy_backptr() OUTBUF_PADDED optimisation */

         s->frame.data[0] = av_malloc(s->width*s->height + 12);

         if (!s->frame.data[0])

             return AVERROR(ENOMEM);

@@ -801,7 +801,7 @@ void ff_er_frame_end(MpegEncContext *s){

     if(!s->error_recognition || s->error_count==0 || s->avctx->lowres ||

        s->avctx->hwaccel ||

        s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU ||

-       s->picture_structure != PICT_FRAME || // we dont support ER of field pictures yet, though it should not crash if enabled

+       s->picture_structure != PICT_FRAME || // we do not support ER of field pictures yet, though it should not crash if enabled

        s->error_count==3*s->mb_width*(s->avctx->skip_top + s->avctx->skip_bottom)) return;

     if (s->current_picture.f.motion_val[0] == NULL) {

@@ -153,7 +153,7 @@ static int g722_encode_trellis(AVCodecContext *avctx,

         for (j = 0; j < frontier && nodes[0][j]; j++) {

             /* Only k >> 2 affects the future adaptive state, therefore testing

-             * small steps that don't change k >> 2 is useless, the orignal

+             * small steps that don't change k >> 2 is useless, the original

              * value from encode_low is better than them. Since we step k

              * in steps of 4, make sure range is a multiple of 4, so that

              * we don't miss the original value from encode_low. */

@@ -2201,8 +2201,8 @@ static av_always_inline void hl_decode_mb_444_internal(H264Context *h, int simpl

 static void hl_decode_mb_simple_ ## bits(H264Context *h){ \

     hl_decode_mb_internal(h, 1, sh); \

 }

-hl_decode_mb_simple(0, 8);

-hl_decode_mb_simple(1, 16);

+hl_decode_mb_simple(0, 8)

+hl_decode_mb_simple(1, 16)

 /**

  * Process a macroblock; this handles edge cases, such as interlacing.

@@ -2926,7 +2926,7 @@ static int decode_slice_header(H264Context *h, H264Context *h0){

              * FIXME: avoiding a memcpy would be nice, but ref handling makes many assumptions

              * about there being no actual duplicates.

              * FIXME: this doesn't copy padding for out-of-frame motion vectors.  Given we're

-             * concealing a lost frame, this probably isn't noticable by comparison, but it should

+             * concealing a lost frame, this probably isn't noticeable by comparison, but it should

              * be fixed. */

             if (h->short_ref_count) {

                 if (prev) {

@@ -3354,7 +3354,7 @@ static av_always_inline void fill_filter_caches_inter(H264Context *h, MpegEncCon

 /**

  *

- * @return non zero if the loop filter can be skiped

+ * @return non zero if the loop filter can be skipped

  */

 static int fill_filter_caches(H264Context *h, int mb_type){

     MpegEncContext * const s = &h->s;

@@ -3879,7 +3879,7 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){

                 av_log(h->s.avctx, AV_LOG_ERROR, "Invalid mix of idr and non-idr slices");

                 return -1;

             }

-            idr(h); //FIXME ensure we don't loose some frames if there is reordering

+            idr(h); // FIXME ensure we don't lose some frames if there is reordering

         case NAL_SLICE:

             init_get_bits(&hx->s.gb, ptr, bit_length);

             hx->intra_gb_ptr=

@@ -388,9 +388,9 @@ static void FUNCC(pred16x16_##n##_dc)(uint8_t *_src, int stride){\

     PREDICT_16x16_DC(PIXEL_SPLAT_X4(v));\

 }

-PRED16x16_X(127, (1<<(BIT_DEPTH-1))-1);

-PRED16x16_X(128, (1<<(BIT_DEPTH-1))+0);

-PRED16x16_X(129, (1<<(BIT_DEPTH-1))+1);

+PRED16x16_X(127, (1<<(BIT_DEPTH-1))-1)

+PRED16x16_X(128, (1<<(BIT_DEPTH-1))+0)

+PRED16x16_X(129, (1<<(BIT_DEPTH-1))+1)

 static inline void FUNCC(pred16x16_plane_compat)(uint8_t *p_src, int p_stride, const int svq3, const int rv40){

   int i, j, k;

@@ -502,9 +502,9 @@ static void FUNCC(pred8x8_##n##_dc)(uint8_t *_src, int stride){\

     }\

 }

-PRED8x8_X(127, (1<<(BIT_DEPTH-1))-1);

-PRED8x8_X(128, (1<<(BIT_DEPTH-1))+0);

-PRED8x8_X(129, (1<<(BIT_DEPTH-1))+1);

+PRED8x8_X(127, (1<<(BIT_DEPTH-1))-1)

+PRED8x8_X(128, (1<<(BIT_DEPTH-1))+0)

+PRED8x8_X(129, (1<<(BIT_DEPTH-1))+1)

 static void FUNCC(pred8x16_128_dc)(uint8_t *_src, int stride){

     FUNCC(pred8x8_128_dc)(_src, stride);

@@ -340,7 +340,7 @@ FUNC(ff_jpeg_fdct_islow)(DCTELEM *data)

 /*

  * The secret of DCT2-4-8 is really simple -- you do the usual 1-DCT

- * on the rows and then, instead of doing even and odd, part on the colums

+ * on the rows and then, instead of doing even and odd, part on the columns

  * you do even part two times.

  */

 GLOBAL(void)

@@ -67,7 +67,7 @@ typedef struct LPCContext {

      * Perform autocorrelation on input samples with delay of 0 to lag.

      * @param data  input samples.

      *              constraints: no alignment needed, but must have have at

-     *              least lag*sizeof(double) valid bytes preceeding it, and

+     *              least lag*sizeof(double) valid bytes preceding it, and

      *              size must be at least (len+1)*sizeof(double) if data is

      *              16-byte aligned or (len+2)*sizeof(double) if data is

      *              unaligned.

@@ -1114,9 +1114,9 @@ static int mjpeg_decode_app(MJpegDecodeContext *s)

         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);

     }

-    /* buggy AVID, it puts EOI only at every 10th frame */

-    /* also this fourcc is used by non-avid files too, it holds some

-       informations, but it's always present in AVID creates files */

+    /* Buggy AVID, it puts EOI only at every 10th frame. */

+    /* Also, this fourcc is used by non-avid files too, it holds some

+       information, but it's always present in AVID-created files. */

     if (id == AV_RL32("AVI1"))

     {

         /* structure:

@@ -559,7 +559,7 @@ static int decode_slice(AVCodecContext *avctx, ProresThreadData *td)

     sf = sf > 128 ? (sf - 96) << 2 : sf;

     /* scale quantization matrixes according with slice's scale factor */

-    /* TODO: this can be SIMD-optimized alot */

+    /* TODO: this can be SIMD-optimized a lot */

     if (ctx->qmat_changed || sf != ctx->prev_slice_sf) {

         ctx->prev_slice_sf = sf;

         for (i = 0; i < 64; i++) {

@@ -156,7 +156,7 @@ static av_cold int decode_init(AVCodecContext *avctx)

              return -1;

     }

     c->bpp = avctx->bits_per_coded_sample;

-    // buffer size for RLE 'best' case when 2-byte code preceeds each pixel and there may be padding after it too

+    // buffer size for RLE 'best' case when 2-byte code precedes each pixel and there may be padding after it too

     c->decomp_size = (((avctx->width * c->bpp + 7) >> 3) + 3 * avctx->width + 2) * avctx->height + 2;

     /* Allocate decompression buffer */

@@ -544,7 +544,8 @@ void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic){

         avci->buffer_count--;

         last = &avci->buffer[avci->buffer_count];

-        FFSWAP(InternalBuffer, *buf, *last);

+        if (buf != last)

+            FFSWAP(InternalBuffer, *buf, *last);

     }

     for (i = 0; i < AV_NUM_DATA_POINTERS; i++) {

@@ -98,7 +98,7 @@ static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_

         pic_param->forward_reference_picture  = ff_vaapi_get_surface_id(&s->last_picture);

     /* Fill in VAIQMatrixBufferMPEG4 */

-    /* Only the first inverse quantisation method uses the weighthing matrices */

+    /* Only the first inverse quantisation method uses the weighting matrices */

     if (pic_param->vol_fields.bits.quant_type) {

         iq_matrix = ff_vaapi_alloc_iq_matrix(vactx, sizeof(VAIQMatrixBufferMPEG4));

         if (!iq_matrix)

@@ -3536,7 +3536,7 @@ static void vc1_apply_p_loop_filter(VC1Context *v)

         vc1_apply_p_v_loop_filter(v, i);

     }

-    /* V always preceedes H, therefore we run H one MB before V;

+    /* V always precedes H, therefore we run H one MB before V;

      * at the end of a row, we catch up to complete the row */

     if (s->mb_x) {

         for (i = 0; i < 6; i++) {

@@ -3573,7 +3573,7 @@ static int vc1_decode_p_mb(VC1Context *v)

     int skipped, fourmv;

     int block_cbp = 0, pat, block_tt = 0, block_intra = 0;

-    mquant = v->pq; /* Loosy initialization */

+    mquant = v->pq; /* lossy initialization */

     if (v->mv_type_is_raw)

         fourmv = get_bits1(gb);

@@ -4141,7 +4141,7 @@ static void vc1_decode_b_mb(VC1Context *v)

     int dmv_x[2], dmv_y[2];

     int bmvtype = BMV_TYPE_BACKWARD;

-    mquant      = v->pq; /* Loosy initialization */

+    mquant      = v->pq; /* lossy initialization */

     s->mb_intra = 0;

     if (v->dmb_is_raw)

@@ -550,8 +550,8 @@ static av_always_inline int vc1_mspel_ ## DIR ## _filter_16bits(const TYPE *src,

     return 0; /* should not occur */                                    \

 }

-VC1_MSPEL_FILTER_16B(ver, uint8_t);

-VC1_MSPEL_FILTER_16B(hor, int16_t);

+VC1_MSPEL_FILTER_16B(ver, uint8_t)

+VC1_MSPEL_FILTER_16B(hor, int16_t)

 /** Filter used to interpolate fractional pel values

@@ -86,6 +86,7 @@

  * subframe in order to reconstruct the output samples.

  */

+#include "libavutil/intfloat.h"

 #include "libavutil/intreadwrite.h"

 #include "avcodec.h"

 #include "internal.h"

@@ -823,8 +824,8 @@ static int decode_coeffs(WMAProDecodeCtx *s, int c)

                     v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);

                     if (v1 == HUFF_VEC1_SIZE - 1)

                         v1 += ff_wma_get_large_val(&s->gb);

-                    vals[i  ] = ((av_alias32){ .f32 = v0 }).u32;

-                    vals[i+1] = ((av_alias32){ .f32 = v1 }).u32;

+                    vals[i  ] = av_float2int(v0);

+                    vals[i+1] = av_float2int(v1);

                 } else {

                     vals[i]   = fval_tab[symbol_to_vec2[idx] >> 4 ];

                     vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];

@@ -1425,7 +1426,7 @@ static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)

  *@param s codec context

  *@param gb bitstream reader context

  *@param len length of the partial frame

- *@param append decides wether to reset the buffer or not

+ *@param append decides whether to reset the buffer or not

  */

 static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,

                       int append)

@@ -189,7 +189,7 @@ typedef struct {

      * @{

      */

     int spillover_nbits;          ///< number of bits of the previous packet's

-                                  ///< last superframe preceeding this

+                                  ///< last superframe preceding this

                                   ///< packet's first full superframe (useful

                                   ///< for re-synchronization also)

     int has_residual_lsps;        ///< if set, superframes contain one set of

@@ -1805,7 +1805,7 @@ static int synth_superframe(AVCodecContext *ctx, int *got_frame_ptr)

     s->frame.nb_samples = n_samples;

     samples = (float *)s->frame.data[0];

-    /* Parse frames, optionally preceeded by per-frame (independent) LSPs. */

+    /* Parse frames, optionally preceded by per-frame (independent) LSPs. */

     for (n = 0; n < 3; n++) {

         if (!s->has_residual_lsps) {

             int m;

@@ -27,7 +27,7 @@

 #include "config.h"

 #if HAVE_FAST_CMOV

-#define BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, range, tmp)\

+#define BRANCHLESS_GET_CABAC_UPDATE(ret, statep, low, lowword, range, tmp)\

         "mov    "tmp"       , %%ecx     \n\t"\

         "shl    $17         , "tmp"     \n\t"\

         "cmp    "low"       , "tmp"     \n\t"\

@@ -37,7 +37,7 @@

         "xor    %%ecx       , "ret"     \n\t"\

         "sub    "tmp"       , "low"     \n\t"

 #else /* HAVE_FAST_CMOV */

-#define BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, range, tmp)\

+#define BRANCHLESS_GET_CABAC_UPDATE(ret, statep, low, lowword, range, tmp)\

         "mov    "tmp"       , %%ecx     \n\t"\

         "shl    $17         , "tmp"     \n\t"\

         "sub    "low"       , "tmp"     \n\t"\

@@ -51,14 +51,13 @@

         "xor    "tmp"       , "ret"     \n\t"

 #endif /* HAVE_FAST_CMOV */

-#define BRANCHLESS_GET_CABAC(ret, cabac, statep, low, lowword, range, tmp, tmpbyte, byte) \

+#define BRANCHLESS_GET_CABAC(ret, statep, low, lowword, range, tmp, tmpbyte, byte) \

         "movzbl "statep"    , "ret"                                     \n\t"\

         "mov    "range"     , "tmp"                                     \n\t"\

         "and    $0xC0       , "range"                                   \n\t"\

         "movzbl "MANGLE(ff_h264_lps_range)"("ret", "range", 2), "range" \n\t"\

         "sub    "range"     , "tmp"                                     \n\t"\

-        BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword,        \

-                                    range, tmp)                              \

+        BRANCHLESS_GET_CABAC_UPDATE(ret, statep, low, lowword, range, tmp)   \

         "movzbl " MANGLE(ff_h264_norm_shift) "("range"), %%ecx          \n\t"\

         "shl    %%cl        , "range"                                   \n\t"\

         "movzbl "MANGLE(ff_h264_mlps_state)"+128("ret"), "tmp"          \n\t"\

@@ -66,8 +65,8 @@

         "mov    "tmpbyte"   , "statep"                                  \n\t"\

         "test   "lowword"   , "lowword"                                 \n\t"\

         " jnz   1f                                                      \n\t"\

-        "mov "byte"("cabac"), %%"REG_c"                                 \n\t"\

-        "add"OPSIZE" $2     , "byte    "("cabac")                       \n\t"\

+        "mov    "byte"      , %%"REG_c"                                 \n\t"\

+        "add"OPSIZE" $2     , "byte"                                    \n\t"\

         "movzwl (%%"REG_c")     , "tmp"                                 \n\t"\

         "lea    -1("low")   , %%ecx                                     \n\t"\

         "xor    "low"       , %%ecx                                     \n\t"\

@@ -82,38 +81,32 @@

         "add    "tmp"       , "low"                                     \n\t"\

         "1:                                                             \n\t"

-#if HAVE_7REGS && !defined(BROKEN_RELOCATIONS)

+#if HAVE_6REGS && !defined(BROKEN_RELOCATIONS)

 #define get_cabac_inline get_cabac_inline_x86

 static av_always_inline int get_cabac_inline_x86(CABACContext *c,

                                                  uint8_t *const state)

 {

-    int bit, low, range, tmp;

+    int bit, tmp;

     __asm__ volatile(

-        "movl %a6(%5), %2               \n\t"

-        "movl %a7(%5), %1               \n\t"

-        BRANCHLESS_GET_CABAC("%0", "%5", "(%4)", "%1", "%w1", "%2",

-                             "%3", "%b3", "%a8")

-        "movl %2, %a6(%5)               \n\t"

-        "movl %1, %a7(%5)               \n\t"

-

-        :"=&r"(bit), "=&r"(low), "=&r"(range), "=&q"(tmp)

-        :"r"(state), "r"(c),

-         "i"(offsetof(CABACContext, range)), "i"(offsetof(CABACContext, low)),

-         "i"(offsetof(CABACContext, bytestream))

+        BRANCHLESS_GET_CABAC("%0", "(%5)", "%1", "%w1", "%2",

+                             "%3", "%b3", "%4")

+        :"=&r"(bit), "+&r"(c->low), "+&r"(c->range), "=&q"(tmp),

+         "+m"(c->bytestream)

+        :"r"(state)

         : "%"REG_c, "memory"

     );

     return bit & 1;

 }

-#endif /* HAVE_7REGS && !defined(BROKEN_RELOCATIONS) */

+#endif /* HAVE_6REGS && !defined(BROKEN_RELOCATIONS) */

 #define get_cabac_bypass_sign get_cabac_bypass_sign_x86

 static av_always_inline int get_cabac_bypass_sign_x86(CABACContext *c, int val)

 {

     x86_reg tmp;

     __asm__ volatile(

-        "movl %a3(%2), %k1                      \n\t"

-        "movl %a4(%2), %%eax                    \n\t"

+        "movl %4, %k1                           \n\t"

+        "movl %2, %%eax                         \n\t"

         "shl $17, %k1                           \n\t"

         "add %%eax, %%eax                       \n\t"

         "sub %k1, %%eax                         \n\t"

@@ -124,22 +117,20 @@ static av_always_inline int get_cabac_bypass_sign_x86(CABACContext *c, int val)

         "sub %%edx, %%ecx                       \n\t"

         "test %%ax, %%ax                        \n\t"

         " jnz 1f                                \n\t"

-        "mov  %a5(%2), %1                       \n\t"

+        "mov  %3, %1                            \n\t"

         "subl $0xFFFF, %%eax                    \n\t"

         "movzwl (%1), %%edx                     \n\t"

         "bswap %%edx                            \n\t"

         "shrl $15, %%edx                        \n\t"

         "add  $2, %1                            \n\t"

         "addl %%edx, %%eax                      \n\t"

-        "mov  %1, %a5(%2)                       \n\t"

+        "mov  %1, %3                            \n\t"

         "1:                                     \n\t"

-        "movl %%eax, %a4(%2)                    \n\t"

+        "movl %%eax, %2                         \n\t"

-        :"+c"(val), "=&r"(tmp)

-        :"r"(c),

-         "i"(offsetof(CABACContext, range)), "i"(offsetof(CABACContext, low)),

-         "i"(offsetof(CABACContext, bytestream))

-        : "%eax", "%edx", "memory"

+        :"+c"(val), "=&r"(tmp), "+m"(c->low), "+m"(c->bytestream)

+        :"m"(c->range)

+        : "%eax", "%edx"

     );

     return val;

 }

@@ -36,7 +36,7 @@

 //FIXME use some macros to avoid duplicating get_cabac (cannot be done yet

 //as that would make optimization work hard)

-#if HAVE_7REGS && !defined(BROKEN_RELOCATIONS)

+#if HAVE_6REGS && !defined(BROKEN_RELOCATIONS)

 static int decode_significance_x86(CABACContext *c, int max_coeff,

                                    uint8_t *significant_coeff_ctx_base,

                                    int *index, x86_reg last_off){

@@ -48,15 +48,15 @@ static int decode_significance_x86(CABACContext *c, int max_coeff,

     __asm__ volatile(

         "2:                                     \n\t"

-        BRANCHLESS_GET_CABAC("%4", "%6", "(%1)", "%3",

-                             "%w3", "%5", "%k0", "%b0", "%a11")

+        BRANCHLESS_GET_CABAC("%4", "(%1)", "%3",

+                             "%w3", "%5", "%k0", "%b0", "%6")

         "test $1, %4                            \n\t"

         " jz 3f                                 \n\t"

         "add  %10, %1                           \n\t"

-        BRANCHLESS_GET_CABAC("%4", "%6", "(%1)", "%3",

-                             "%w3", "%5", "%k0", "%b0", "%a11")

+        BRANCHLESS_GET_CABAC("%4", "(%1)", "%3",

+                             "%w3", "%5", "%k0", "%b0", "%6")

         "sub  %10, %1                           \n\t"

         "mov  %2, %0                            \n\t"

@@ -81,9 +81,9 @@ static int decode_significance_x86(CABACContext *c, int max_coeff,

         "add  %9, %k0                           \n\t"

         "shr $2, %k0                            \n\t"

         :"=&q"(coeff_count), "+r"(significant_coeff_ctx_base), "+m"(index),

-         "+&r"(c->low), "=&r"(bit), "+&r"(c->range)

-        :"r"(c), "m"(minusstart), "m"(end), "m"(minusindex), "m"(last_off),

-         "i"(offsetof(CABACContext, bytestream))

+         "+&r"(c->low), "=&r"(bit), "+&r"(c->range),

+         "+m"(c->bytestream)

+        :"m"(minusstart), "m"(end), "m"(minusindex), "m"(last_off)

         : "%"REG_c, "memory"

     );

     return coeff_count;

@@ -105,8 +105,8 @@ static int decode_significance_8x8_x86(CABACContext *c,

         "movzbl (%0, %6), %k6                   \n\t"

         "add %9, %6                             \n\t"

-        BRANCHLESS_GET_CABAC("%4", "%7", "(%6)", "%3",

-                             "%w3", "%5", "%k0", "%b0", "%a12")

+        BRANCHLESS_GET_CABAC("%4", "(%6)", "%3",

+                             "%w3", "%5", "%k0", "%b0", "%7")

         "mov %1, %k6                            \n\t"

         "test $1, %4                            \n\t"

@@ -115,8 +115,8 @@ static int decode_significance_8x8_x86(CABACContext *c,

         "movzbl "MANGLE(last_coeff_flag_offset_8x8)"(%k6), %k6\n\t"

         "add %11, %6                            \n\t"

-        BRANCHLESS_GET_CABAC("%4", "%7", "(%6)", "%3",

-                             "%w3", "%5", "%k0", "%b0", "%a12")

+        BRANCHLESS_GET_CABAC("%4", "(%6)", "%3",

+                             "%w3", "%5", "%k0", "%b0", "%7")

         "mov %2, %0                             \n\t"

         "mov %1, %k6                            \n\t"

@@ -138,13 +138,12 @@ static int decode_significance_8x8_x86(CABACContext *c,

         "addl %8, %k0                           \n\t"

         "shr $2, %k0                            \n\t"

         :"=&q"(coeff_count),"+m"(last), "+m"(index), "+&r"(c->low), "=&r"(bit),

-         "+&r"(c->range), "=&r"(state)

-        :"r"(c), "m"(minusindex), "m"(significant_coeff_ctx_base), "m"(sig_off), "m"(last_coeff_ctx_base),

-         "i"(offsetof(CABACContext, bytestream))

+         "+&r"(c->range), "=&r"(state), "+m"(c->bytestream)

+        :"m"(minusindex), "m"(significant_coeff_ctx_base), "m"(sig_off), "m"(last_coeff_ctx_base)

         : "%"REG_c, "memory"

     );

     return coeff_count;

 }

-#endif /* HAVE_7REGS && !defined(BROKEN_RELOCATIONS) */

+#endif /* HAVE_6REGS && !defined(BROKEN_RELOCATIONS) */

 #endif /* AVCODEC_X86_H264_I386_H */

@@ -227,7 +227,7 @@ section .text

     imul r2, 0x01010101

 %endmacro

-; I dont know why the sign extension is needed...

+; I do not know why the sign extension is needed...

 %macro PSIGNW_SRA_MMX 2

     psraw %2, 15

     PSIGNW_MMX %1, %2

@@ -272,7 +272,7 @@ static int audio_read_packet(AVFormatContext *context, AVPacket *pkt)

         }

     }

-    /* Wait for a packet comming back from process_callback(), if one isn't available yet */

+    /* Wait for a packet coming back from process_callback(), if one isn't available yet */

     timeout.tv_sec = av_gettime() / 1000000 + 2;

     if (sem_timedwait(&self->packet_count, &timeout)) {

         if (errno == ETIMEDOUT) {

@@ -72,7 +72,7 @@ TimeFilter * ff_timefilter_new(double clock_period, double feedback2_factor, dou

  *

  * system_time, in seconds, should be the value of the system clock time,

  * at (or as close as possible to) the moment the device hardware interrupt

- * occured (or any other event the device clock raises at the beginning of a

+ * occurred (or any other event the device clock raises at the beginning of a

  * cycle).

  *

  * @return the filtered time, in seconds

@@ -28,7 +28,7 @@

  */

 #include "libavutil/intreadwrite.h"

-#include "libavutil/intfloat_readwrite.h"

+#include "libavutil/intfloat.h"

 #include "avformat.h"

 #include "internal.h"

@@ -131,7 +131,7 @@ static int fourxm_read_header(AVFormatContext *s,

         size = AV_RL32(&header[i + 4]);

         if (fourcc_tag == std__TAG) {

-            fourxm->fps = av_int2flt(AV_RL32(&header[i + 12]));

+            fourxm->fps = av_int2float(AV_RL32(&header[i + 12]));

         } else if (fourcc_tag == vtrk_TAG) {

             /* check that there is enough data */

             if (size != vtrk_SIZE) {

@@ -19,7 +19,7 @@

  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  */

-#include "libavutil/intfloat_readwrite.h"

+#include "libavutil/mathematics.h"

 #include "libavutil/dict.h"

 #include "avformat.h"

 #include "internal.h"

@@ -90,7 +90,8 @@ static void get_meta(AVFormatContext *s, const char *key, int size)

 static unsigned int get_aiff_header(AVIOContext *pb, AVCodecContext *codec,

                              int size, unsigned version)

 {

-    AVExtFloat ext;

+    int exp;

+    uint64_t val;

     double sample_rate;

     unsigned int num_frames;

@@ -101,8 +102,9 @@ static unsigned int get_aiff_header(AVIOContext *pb, AVCodecContext *codec,

     num_frames = avio_rb32(pb);

     codec->bits_per_coded_sample = avio_rb16(pb);

-    avio_read(pb, (uint8_t*)&ext, sizeof(ext));/* Sample rate is in */

-    sample_rate = av_ext2dbl(ext);          /* 80 bits BE IEEE extended float */

+    exp = avio_rb16(pb);

+    val = avio_rb64(pb);

+    sample_rate = ldexp(val, exp - 16383 - 63);

     codec->sample_rate = sample_rate;

     size -= 18;

@@ -19,7 +19,7 @@

  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  */

-#include "libavutil/intfloat_readwrite.h"

+#include "libavutil/intfloat.h"

 #include "avformat.h"

 #include "internal.h"

 #include "aiff.h"

@@ -37,7 +37,7 @@ static int aiff_write_header(AVFormatContext *s)

     AIFFOutputContext *aiff = s->priv_data;

     AVIOContext *pb = s->pb;

     AVCodecContext *enc = s->streams[0]->codec;

-    AVExtFloat sample_rate;

+    uint64_t sample_rate;

     int aifc = 0;

     /* First verify if format is ok */

@@ -89,8 +89,9 @@ static int aiff_write_header(AVFormatContext *s)

     avio_wb16(pb, enc->bits_per_coded_sample); /* Sample size */

-    sample_rate = av_dbl2ext((double)enc->sample_rate);

-    avio_write(pb, (uint8_t*)&sample_rate, sizeof(sample_rate));

+    sample_rate = av_double2int(enc->sample_rate);

+    avio_wb16(pb, (sample_rate >> 52) + (16383 - 1023));

+    avio_wb64(pb, UINT64_C(1) << 63 | sample_rate << 11);

     if (aifc) {

         avio_wl32(pb, enc->codec_tag);

@@ -697,7 +697,8 @@ typedef struct AVStream {

     /**

      * last packet in packet_buffer for this stream when muxing.

-     * used internally, NOT PART OF PUBLIC API, dont read or write from outside of libav*

+     * Used internally, NOT PART OF PUBLIC API, do not read or

+     * write from outside of libav*

      */

     struct AVPacketList *last_in_packet_buffer;

 #endif

@@ -731,7 +732,7 @@ typedef struct AVStream {

     int64_t interleaver_chunk_duration;

     /**

-     * Stream informations used internally by av_find_stream_info()

+     * Stream information used internally by av_find_stream_info()

      */

 #define MAX_STD_TIMEBASES (60*12+5)

     struct {

@@ -909,7 +910,7 @@ typedef struct AVFormatContext {

     /**

      * Decoding: duration of the stream, in AV_TIME_BASE fractional

      * seconds. Only set this value if you know none of the individual stream

-     * durations and also dont set any of them. This is deduced from the

+     * durations and also do not set any of them. This is deduced from the

      * AVStream values if not set.

      */

     int64_t duration;

@@ -30,7 +30,7 @@

 #include "riff.h"

 #include "isom.h"

 #include "libavutil/intreadwrite.h"

-#include "libavutil/intfloat_readwrite.h"

+#include "libavutil/intfloat.h"

 #include "libavutil/dict.h"

 #include "caf.h"

@@ -68,7 +68,7 @@ static int read_desc_chunk(AVFormatContext *s)

     /* parse format description */

     st->codec->codec_type  = AVMEDIA_TYPE_AUDIO;

-    st->codec->sample_rate = av_int2dbl(avio_rb64(pb));

+    st->codec->sample_rate = av_int2double(avio_rb64(pb));

     st->codec->codec_tag   = avio_rl32(pb);

     flags = avio_rb32(pb);

     caf->bytes_per_packet  = avio_rb32(pb);

@@ -20,7 +20,7 @@

  */

 #include "libavutil/intreadwrite.h"

-#include "libavutil/intfloat_readwrite.h"

+#include "libavutil/intfloat.h"

 #include "avformat.h"

 #include "internal.h"

 #include "ffm.h"

@@ -329,10 +329,10 @@ static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)

             codec->rc_max_rate = avio_rb32(pb);

             codec->rc_min_rate = avio_rb32(pb);

             codec->rc_buffer_size = avio_rb32(pb);

-            codec->i_quant_factor = av_int2dbl(avio_rb64(pb));

-            codec->b_quant_factor = av_int2dbl(avio_rb64(pb));

-            codec->i_quant_offset = av_int2dbl(avio_rb64(pb));

-            codec->b_quant_offset = av_int2dbl(avio_rb64(pb));

+            codec->i_quant_factor = av_int2double(avio_rb64(pb));

+            codec->b_quant_factor = av_int2double(avio_rb64(pb));

+            codec->i_quant_offset = av_int2double(avio_rb64(pb));

+            codec->b_quant_offset = av_int2double(avio_rb64(pb));

             codec->dct_algo = avio_rb32(pb);

             codec->strict_std_compliance = avio_rb32(pb);

             codec->max_b_frames = avio_rb32(pb);

@@ -344,7 +344,7 @@ static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)

             codec->mb_decision = avio_rb32(pb);

             codec->nsse_weight = avio_rb32(pb);

             codec->frame_skip_cmp = avio_rb32(pb);

-            codec->rc_buffer_aggressivity = av_int2dbl(avio_rb64(pb));

+            codec->rc_buffer_aggressivity = av_int2double(avio_rb64(pb));

             codec->codec_tag = avio_rb32(pb);

             codec->thread_count = avio_r8(pb);

             codec->coder_type = avio_rb32(pb);

@@ -355,8 +355,8 @@ static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)

             codec->keyint_min = avio_rb32(pb);

             codec->scenechange_threshold = avio_rb32(pb);

             codec->b_frame_strategy = avio_rb32(pb);

-            codec->qcompress = av_int2dbl(avio_rb64(pb));

-            codec->qblur = av_int2dbl(avio_rb64(pb));

+            codec->qcompress = av_int2double(avio_rb64(pb));

+            codec->qblur = av_int2double(avio_rb64(pb));

             codec->max_qdiff = avio_rb32(pb);

             codec->refs = avio_rb32(pb);

             codec->directpred = avio_rb32(pb);

@@ -20,7 +20,7 @@

  */

 #include "libavutil/intreadwrite.h"

-#include "libavutil/intfloat_readwrite.h"

+#include "libavutil/intfloat.h"

 #include "avformat.h"

 #include "internal.h"

 #include "ffm.h"

@@ -137,10 +137,10 @@ static int ffm_write_header(AVFormatContext *s)

             avio_wb32(pb, codec->rc_max_rate);

             avio_wb32(pb, codec->rc_min_rate);

             avio_wb32(pb, codec->rc_buffer_size);

-            avio_wb64(pb, av_dbl2int(codec->i_quant_factor));

-            avio_wb64(pb, av_dbl2int(codec->b_quant_factor));

-            avio_wb64(pb, av_dbl2int(codec->i_quant_offset));

-            avio_wb64(pb, av_dbl2int(codec->b_quant_offset));