Revision 755bfeab

View differences:

doc/TODO
79 79
- macroblock based pixel format (better cache locality, somewhat complex, one paper claimed it faster for high res)
80 80
- NUT muxer
81 81
- seeking regression test
82
- regression tests for codecs which dont have an encoder (I+P frame bitstream in svn)
82
- regression tests for codecs which do not have an encoder (I+P-frame bitstream in svn)
83 83
- add support for using mplayers video filters to ffmpeg
84 84
- reverse engeneer RV30/RV40
85 85
- finish implementation of WMV2 j-picture
doc/avutil.txt
34 34
* Modular (few interdependencies and the possibility of disabling individual parts during ./configure)
35 35
* Small (source and object)
36 36
* Efficient (low CPU and memory usage)
37
* Useful (avoid useless features almost noone needs)
37
* Useful (avoid useless features almost no one needs)
doc/ffmpeg-doc.texi
1595 1595
   list, reference the thread in the log message.
1596 1596
@item
1597 1597
    Do NOT commit to code actively maintained by others without permission.
1598
    Send a patch to ffmpeg-devel instead. If noone answers within a reasonable
1598
    Send a patch to ffmpeg-devel instead. If no one answers within a reasonable
1599 1599
    timeframe (12h for build failures and security fixes, 3 days small changes,
1600 1600
    1 week for big patches) then commit your patch if you think it is OK.
1601 1601
    Also note, the maintainer can simply ask for more time to review!
ffmpeg.c
3277 3277
    }
3278 3278
    printf("\n\n");
3279 3279
    printf(
3280
"Note, the names of encoders and decoders dont always match, so there are\n"
3280
"Note, the names of encoders and decoders do not always match, so there are\n"
3281 3281
"several cases where the above table shows encoder only or decoder only entries\n"
3282
"even though both encoding and decoding are supported for example, the h263\n"
3283
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3284
"worse\n");
3282
"even though both encoding and decoding are supported. For example, the h263\n"
3283
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3284
"worse.\n");
3285 3285
    exit(1);
3286 3286
}
3287 3287

  
ffplay.c
1924 1924
            ret = -1;
1925 1925
            goto fail;
1926 1926
        }
1927
        ic->pb.eof_reached= 0; //FIXME hack, ffplay maybe shouldnt use url_feof() to test for the end
1927
        ic->pb.eof_reached= 0; //FIXME hack, ffplay maybe should not use url_feof() to test for the end
1928 1928
    }
1929 1929

  
1930 1930
    /* if seeking requested, we execute it */
ffserver.c
1299 1299
        }
1300 1300
    }
1301 1301

  
1302
    /* If already streaming this feed, dont let start an another feeder */
1302
    /* If already streaming this feed, do not let start another feeder. */
1303 1303
    if (stream->feed_opened) {
1304 1304
        snprintf(msg, sizeof(msg), "This feed is already being received.");
1305 1305
        goto send_error;
libavcodec/apiexample.c
336 336
    picture= avcodec_alloc_frame();
337 337

  
338 338
    if(codec->capabilities&CODEC_CAP_TRUNCATED)
339
        c->flags|= CODEC_FLAG_TRUNCATED; /* we dont send complete frames */
339
        c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
340 340

  
341
    /* for some codecs, such as msmpeg4 and mpeg4, width and height
342
       MUST be initialized there because these info are not available
343
       in the bitstream */
341
    /* For some codecs, such as msmpeg4 and mpeg4, width and height
342
       MUST be initialized there because this information is not
343
       available in the bitstream. */
344 344

  
345 345
    /* open it */
346 346
    if (avcodec_open(c, codec) < 0) {
libavcodec/audioconvert.c
54 54
    }while(po < end);\
55 55
}
56 56

  
57
//FIXME put things below under ifdefs so we dont waste space for cases no codec will need
58
//FIXME rounding and cliping ?
57
//FIXME put things below under ifdefs so we do not waste space for cases no codec will need
58
//FIXME rounding and clipping ?
59 59

  
60 60
             CONV(SAMPLE_FMT_U8 , uint8_t, SAMPLE_FMT_U8 ,  *(uint8_t*)pi)
61 61
        else CONV(SAMPLE_FMT_S16, int16_t, SAMPLE_FMT_U8 , (*(uint8_t*)pi - 0x80)<<8)
libavcodec/avcodec.h
2885 2885
/**
2886 2886
 * Parses \p str and put in \p width_ptr and \p height_ptr the detected values.
2887 2887
 *
2888
 * @return 0 in case of a successfull parsing, a negative value otherwise
2888
 * @return 0 in case of a successful parsing, a negative value otherwise
2889 2889
 * @param[in] str the string to parse: it has to be a string in the format
2890 2890
 * <width>x<height> or a valid video frame size abbreviation.
2891 2891
 * @param[in,out] width_ptr pointer to the variable which will contain the detected
......
2898 2898
/**
2899 2899
 * Parses \p str and put in \p frame_rate the detected values.
2900 2900
 *
2901
 * @return 0 in case of a successfull parsing, a negative value otherwise
2901
 * @return 0 in case of a successful parsing, a negative value otherwise
2902 2902
 * @param[in] str the string to parse: it has to be a string in the format
2903 2903
 * <frame_rate_nom>/<frame_rate_den>, a float number or a valid video rate abbreviation
2904 2904
 * @param[in,out] frame_rate pointer to the AVRational which will contain the detected
libavcodec/beosthread.c
73 73
}
74 74

  
75 75
/**
76
 * free what has been allocated by avcodec_thread_init().
77
 * must be called after decoding has finished, especially dont call while avcodec_thread_execute() is running
76
 * Free what has been allocated by avcodec_thread_init().
77
 * Must be called after decoding has finished, especially do not call while avcodec_thread_execute() is running.
78 78
 */
79 79
void avcodec_thread_free(AVCodecContext *s){
80 80
    ThreadContext *c= s->thread_opaque;
libavcodec/bitstream.h
335 335
}
336 336

  
337 337
/**
338
 * skips the given number of bits.
339
 * must only be used if the actual values in the bitstream dont matter
338
 * Skips the given number of bits.
339
 * Must only be used if the actual values in the bitstream do not matter.
340 340
 */
341 341
static inline void skip_put_bits(PutBitContext *s, int n){
342 342
#ifdef ALT_BITSTREAM_WRITER
libavcodec/cabac.h
683 683
}
684 684

  
685 685
//FIXME the x86 code from this file should be moved into i386/h264 or cabac something.c/h (note ill kill you if you move my code away from under my fingers before iam finished with it!)
686
//FIXME use some macros to avoid duplicatin get_cabac (cant be done yet as that would make optimization work hard)
686
//FIXME use some macros to avoid duplicatin get_cabac (cannot be done yet as that would make optimization work hard)
687 687
#if defined(ARCH_X86) && defined(CONFIG_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS)
688 688
static int decode_significance_x86(CABACContext *c, int max_coeff, uint8_t *significant_coeff_ctx_base, int *index){
689 689
    void *end= significant_coeff_ctx_base + max_coeff - 1;
libavcodec/dct-test.c
337 337
            for(i=0; i<64; i++)
338 338
                block[i]= block1[i];
339 339
//            memcpy(block, block1, sizeof(DCTELEM) * 64);
340
// dont memcpy especially not fastmemcpy because it does movntq !!!
340
// do not memcpy especially not fastmemcpy because it does movntq !!!
341 341
            fdct_func(block);
342 342
        }
343 343
        it1 += NB_ITS_SPEED;
......
497 497
            for(i=0; i<64; i++)
498 498
                block[i]= block1[i];
499 499
//            memcpy(block, block1, sizeof(DCTELEM) * 64);
500
// dont memcpy especially not fastmemcpy because it does movntq !!!
500
// do not memcpy especially not fastmemcpy because it does movntq !!!
501 501
            idct248_put(img_dest, 8, block);
502 502
        }
503 503
        it1 += NB_ITS_SPEED;
libavcodec/dsputil.h
144 144

  
145 145
/* motion estimation */
146 146
// h is limited to {width/2, width, 2*width} but never larger than 16 and never smaller then 2
147
// allthough currently h<4 is not used as functions with width <8 are not used and neither implemented
147
// although currently h<4 is not used as functions with width <8 are neither used nor implemented
148 148
typedef int (*me_cmp_func)(void /*MpegEncContext*/ *s, uint8_t *blk1/*align width (8 or 16)*/, uint8_t *blk2/*align 1*/, int line_size, int h)/* __attribute__ ((const))*/;
149 149

  
150 150

  
libavcodec/error_resilience.c
108 108
}
109 109

  
110 110
/**
111
 * guess the dc of blocks which dont have a undamaged dc
111
 * guess the dc of blocks which do not have an undamaged dc
112 112
 * @param w     width in 8 pixel blocks
113 113
 * @param h     height in 8 pixel blocks
114 114
 */
libavcodec/flicvideo.c
579 579
                }
580 580

  
581 581
                /* Now FLX is strange, in that it is "byte" as opposed to "pixel" run length compressed.
582
                 * This doesnt give us any good oportunity to perform word endian conversion
583
                 * during decompression. So if its requried (ie, this isnt a LE target, we do
582
                 * This does not give us any good oportunity to perform word endian conversion
583
                 * during decompression. So if it is required (i.e., this is not a LE target, we do
584 584
                 * a second pass over the line here, swapping the bytes.
585 585
                 */
586 586
                pixel = 0xFF00;
......
716 716
                                     buf, buf_size);
717 717
    }
718 718

  
719
    /* Shouldnt get  here, ever as the pix_fmt is processed */
719
    /* Should not get  here, ever as the pix_fmt is processed */
720 720
    /* in flic_decode_init and the above if should deal with */
721 721
    /* the finite set of possibilites allowable by here. */
722
    /* but in case we do, just error out. */
723
    av_log(avctx, AV_LOG_ERROR, "Unknown Format of FLC. My Science cant explain how this happened\n");
722
    /* But in case we do, just error out. */
723
    av_log(avctx, AV_LOG_ERROR, "Unknown FLC format, my science cannot explain how this happened.\n");
724 724
    return -1;
725 725
}
726 726

  
libavcodec/h261dec.c
532 532
 */
533 533
static int get_consumed_bytes(MpegEncContext *s, int buf_size){
534 534
    int pos= get_bits_count(&s->gb)>>3;
535
    if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
535
    if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)
536 536
    if(pos+10>buf_size) pos=buf_size; // oops ;)
537 537

  
538 538
    return pos;
......
565 565
            return -1;
566 566
    }
567 567

  
568
    //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
568
    //we need to set current_picture_ptr before reading the header, otherwise we cannot store anyting im there
569 569
    if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
570 570
        int i= ff_find_unused_picture(s, 0);
571 571
        s->current_picture_ptr= &s->picture[i];
......
580 580
    }
581 581

  
582 582
    if (s->width != avctx->coded_width || s->height != avctx->coded_height){
583
        ParseContext pc= s->parse_context; //FIXME move these demuxng hack to avformat
583
        ParseContext pc= s->parse_context; //FIXME move this demuxing hack to libavformat
584 584
        s->parse_context.buffer=0;
585 585
        MPV_common_end(s);
586 586
        s->parse_context= pc;
libavcodec/h263dec.c
141 141
        if(pos<0) pos=0; // padding is not really read so this might be -1
142 142
        return pos;
143 143
    }else{
144
        if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
144
        if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)
145 145
        if(pos+10>buf_size) pos=buf_size; // oops ;)
146 146

  
147 147
        return pos;
......
382 382
            return -1;
383 383
    }
384 384

  
385
    //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
385
    /* We need to set current_picture_ptr before reading the header,
386
     * otherwise we cannot store anyting in there */
386 387
    if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
387 388
        int i= ff_find_unused_picture(s, 0);
388 389
        s->current_picture_ptr= &s->picture[i];
......
621 622
    ff_er_frame_start(s);
622 623

  
623 624
    //the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type
624
    //which isnt available before MPV_frame_start()
625
    //which is not available before MPV_frame_start()
625 626
    if (s->msmpeg4_version==5){
626 627
        if(!ENABLE_WMV2_DECODER || ff_wmv2_decode_secondary_picture_header(s) < 0)
627 628
            return -1;
libavcodec/h264.c
1602 1602
    return chroma_qp[av_clip(qscale + chroma_qp_index_offset, 0, 51)];
1603 1603
}
1604 1604

  
1605
//FIXME need to check that this doesnt overflow signed 32 bit for low qp, i am not sure, it's very close
1605
//FIXME need to check that this does not overflow signed 32 bit for low qp, i am not sure, it's very close
1606 1606
//FIXME check that gcc inlines this (and optimizes intra & separate_dc stuff away)
1607 1607
static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int separate_dc){
1608 1608
    int i;
......
4816 4816
    if(IS_INTRA_PCM(mb_type)){
4817 4817
        unsigned int x, y;
4818 4818

  
4819
        // we assume these blocks are very rare so we dont optimize it
4819
        // We assume these blocks are very rare so we do not optimize it.
4820 4820
        align_get_bits(&s->gb);
4821 4821

  
4822 4822
        // The pixels are stored in the same order as levels in h->mb array.
......
5957 5957
        const uint8_t *ptr;
5958 5958
        unsigned int x, y;
5959 5959

  
5960
        // We assume these blocks are very rare so we dont optimize it.
5960
        // We assume these blocks are very rare so we do not optimize it.
5961 5961
        // FIXME The two following lines get the bitstream position in the cabac
5962 5962
        // decode, I think it should be done by a function in cabac.h (or cabac.c).
5963 5963
        ptr= h->cabac.bytestream;
......
7721 7721

  
7722 7722
        buf_index += consumed;
7723 7723

  
7724
        if(  (s->hurry_up == 1 && h->nal_ref_idc  == 0) //FIXME dont discard SEI id
7724
        if(  (s->hurry_up == 1 && h->nal_ref_idc  == 0) //FIXME do not discard SEI id
7725 7725
           ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc  == 0))
7726 7726
            continue;
7727 7727

  
......
7818 7818

  
7819 7819
        return pos;
7820 7820
    }else{
7821
        if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
7821
        if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)
7822 7822
        if(pos+10>buf_size) pos=buf_size; // oops ;)
7823 7823

  
7824 7824
        return pos;
......
8084 8084
        START_TIMER
8085 8085
        j= get_ue_golomb(&gb);
8086 8086
        if(j != i){
8087
            printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
8087
            printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
8088 8088
//            return -1;
8089 8089
        }
8090 8090
        STOP_TIMER("get_ue_golomb");
......
8109 8109
        START_TIMER
8110 8110
        j= get_se_golomb(&gb);
8111 8111
        if(j != i - COUNT/2){
8112
            printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
8112
            printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
8113 8113
//            return -1;
8114 8114
        }
8115 8115
        STOP_TIMER("get_se_golomb");
......
8213 8213
        }
8214 8214

  
8215 8215
        if(memcmp(bitstream, out, COUNT)){
8216
            printf("missmatch\n");
8216
            printf("mismatch\n");
8217 8217
            return -1;
8218 8218
        }
8219 8219
    }
libavcodec/h264.h
34 34
#include "mpegvideo.h"
35 35

  
36 36
#define interlaced_dct interlaced_dct_is_a_bad_name
37
#define mb_intra mb_intra_isnt_initalized_see_mb_type
37
#define mb_intra mb_intra_is_not_initalized_see_mb_type
38 38

  
39 39
#define LUMA_DC_BLOCK_INDEX   25
40 40
#define CHROMA_DC_BLOCK_INDEX 26
libavcodec/i386/dsputil_mmx_avg.h
96 96
        "add    $16, %2                 \n\t"
97 97
        "subl   $4, %0                  \n\t"
98 98
        "jnz    1b                      \n\t"
99
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
99
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
100 100
        :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
101 101
#else
102 102
        :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
......
143 143
        "add    $32, %2                 \n\t"
144 144
        "subl   $4, %0                  \n\t"
145 145
        "jnz    1b                      \n\t"
146
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
146
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
147 147
        :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
148 148
#else
149 149
        :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
......
213 213
        "add    $32, %2                 \n\t"
214 214
        "subl   $4, %0                  \n\t"
215 215
        "jnz    1b                      \n\t"
216
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
216
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
217 217
        :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
218 218
#else
219 219
        :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
......
268 268
        "add    $16, %2                 \n\t"
269 269
        "subl   $4, %0                  \n\t"
270 270
        "jnz    1b                      \n\t"
271
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
271
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
272 272
        :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
273 273
#else
274 274
        :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
......
320 320
        "add    $32, %2                 \n\t"
321 321
        "subl   $4, %0                  \n\t"
322 322
        "jnz    1b                      \n\t"
323
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
323
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
324 324
        :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
325 325
#else
326 326
        :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
......
408 408
        "add    $32, %2                 \n\t"
409 409
        "subl   $2, %0                  \n\t"
410 410
        "jnz    1b                      \n\t"
411
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
411
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
412 412
        :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
413 413
#else
414 414
        :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
......
462 462
        "add    $32, %2                 \n\t"
463 463
        "subl   $2, %0                  \n\t"
464 464
        "jnz    1b                      \n\t"
465
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
465
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
466 466
        :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
467 467
#else
468 468
        :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
......
535 535
        "add    $32, %2                 \n\t"
536 536
        "subl   $2, %0                  \n\t"
537 537
        "jnz    1b                      \n\t"
538
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
538
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
539 539
        :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
540 540
#else
541 541
        :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
......
748 748
        :"%"REG_a, "memory");
749 749
}
750 750

  
751
// Note this is not correctly rounded, but this function is only used for b frames so it doesnt matter
751
/* Note this is not correctly rounded, but this function is only
752
 * used for B-frames so it does not matter. */
752 753
static void DEF(avg_pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
753 754
{
754 755
    MOVQ_BONE(mm6);
libavcodec/i386/dsputil_mmx_rnd.h
98 98
        "add    %5, %3                  \n\t"
99 99
        "subl   $4, %0                  \n\t"
100 100
        "jnz    1b                      \n\t"
101
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
101
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
102 102
        :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
103 103
#else
104 104
        :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
......
193 193
        "add    $32, %2                 \n\t"
194 194
        "subl   $2, %0                  \n\t"
195 195
        "jnz    1b                      \n\t"
196
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
196
#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
197 197
        :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
198 198
#else
199 199
        :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
libavcodec/i386/fdct_mmx.c
475 475

  
476 476
static av_always_inline void fdct_row_mmx(const int16_t *in, int16_t *out, const int16_t *table)
477 477
{
478
//FIXME reorder (i dont have a old mmx only cpu here to benchmark ...)
478
//FIXME reorder (I do not have an old MMX-only CPU here to benchmark ...)
479 479
    movd_m2r(*(in + 6), mm1);
480 480
    punpcklwd_m2r(*(in + 4), mm1);
481 481
    movq_r2r(mm1, mm2);
libavcodec/i386/mpegvideo_mmx.c
397 397
                : "%"REG_a, "memory"
398 398
        );
399 399
    block[0]= block0;
400
        //Note, we dont do mismatch control for intra as errors cannot accumulate
400
        //Note, we do not do mismatch control for intra as errors cannot accumulate
401 401
}
402 402

  
403 403
static void dct_unquantize_mpeg2_inter_mmx(MpegEncContext *s,
libavcodec/i386/mpegvideo_mmx_template.c
103 103
    assert((7&(int)(&temp_block[0])) == 0); //did gcc align it correctly?
104 104

  
105 105
    //s->fdct (block);
106
    RENAMEl(ff_fdct) (block); //cant be anything else ...
106
    RENAMEl(ff_fdct) (block); //cannot be anything else ...
107 107

  
108 108
    if(s->dct_error_sum)
109 109
        s->denoise_dct(s, block);
libavcodec/jpeglsenc.c
381 381
    return 0;
382 382
}
383 383

  
384
AVCodec jpegls_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
384
AVCodec jpegls_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them
385 385
    "jpegls",
386 386
    CODEC_TYPE_VIDEO,
387 387
    CODEC_ID_JPEGLS,
libavcodec/libmp3lame.c
188 188
            s->buffer_index -= len;
189 189

  
190 190
            memmove(s->buffer, s->buffer+len, s->buffer_index);
191
            //FIXME fix the audio codec API, so we dont need the memcpy()
191
            //FIXME fix the audio codec API, so we do not need the memcpy()
192 192
/*for(i=0; i<len; i++){
193 193
    av_log(avctx, AV_LOG_DEBUG, "%2X ", frame[i]);
194 194
}*/
libavcodec/ljpegenc.c
186 186
}
187 187

  
188 188

  
189
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
189
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them
190 190
    "ljpeg",
191 191
    CODEC_TYPE_VIDEO,
192 192
    CODEC_ID_LJPEG,
libavcodec/motion_est.c
279 279
        c->uvstride=  8*s->mb_width + 16;
280 280
    }
281 281

  
282
    // 8x8 fullpel search would need a 4x4 chroma compare, which we dont have yet, and even if we had the motion estimation code doesnt expect it
282
    /* 8x8 fullpel search would need a 4x4 chroma compare, which we do
283
     * not have yet, and even if we had, the motion estimation code
284
     * does not expect it. */
283 285
    if(s->codec_id != CODEC_ID_SNOW){
284 286
        if((c->avctx->me_cmp&FF_CMP_CHROMA)/* && !s->dsp.me_cmp[2]*/){
285 287
            s->dsp.me_cmp[2]= zero_cmp;
......
1980 1982
            type |= CANDIDATE_MB_TYPE_BIDIR_I;
1981 1983
        }
1982 1984
         //FIXME something smarter
1983
        if(dmin>256*256*16) type&= ~CANDIDATE_MB_TYPE_DIRECT; //dont try direct mode if its invalid for this MB
1985
        if(dmin>256*256*16) type&= ~CANDIDATE_MB_TYPE_DIRECT; //do not try direct mode if it is invalid for this MB
1984 1986
        if(s->codec_id == CODEC_ID_MPEG4 && type&CANDIDATE_MB_TYPE_DIRECT && s->flags&CODEC_FLAG_MV0 && *(uint32_t*)s->b_direct_mv_table[xy])
1985 1987
            type |= CANDIDATE_MB_TYPE_DIRECT0;
1986 1988
#if 0
libavcodec/mp3_header_decompress_bsf.c
60 60
            break;
61 61
    }
62 62
    if(bitrate_index == 30){
63
        av_log(avctx, AV_LOG_ERROR, "couldnt find bitrate_index\n");
63
        av_log(avctx, AV_LOG_ERROR, "Could not find bitrate_index.\n");
64 64
        return -1;
65 65
    }
66 66

  
libavcodec/mpeg12.c
1000 1000
                /* store the vlc & sign at once */
1001 1001
                put_bits(&s->pb, table_vlc[code][1]+1, (table_vlc[code][0]<<1) + sign);
1002 1002
            } else {
1003
                /* escape seems to be pretty rare <5% so i dont optimize it */
1003
                /* escape seems to be pretty rare <5% so I do not optimize it */
1004 1004
                put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]);
1005 1005
                /* escape: only clip in this case */
1006 1006
                put_bits(&s->pb, 6, run);
......
3178 3178
                int mb_y= start_code - SLICE_MIN_START_CODE;
3179 3179

  
3180 3180
                if(s2->last_picture_ptr==NULL){
3181
                /* skip b frames if we dont have reference frames */
3181
                /* Skip B-frames if we do not have reference frames. */
3182 3182
                    if(s2->pict_type==B_TYPE) break;
3183
                /* skip P frames if we dont have reference frame no valid header */
3183
                /* Skip P-frames if we do not have reference frame no valid header. */
3184 3184
//                    if(s2->pict_type==P_TYPE && s2->first_field && !s2->first_slice) break;
3185 3185
                }
3186
                /* skip b frames if we are in a hurry */
3186
                /* Skip B-frames if we are in a hurry. */
3187 3187
                if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
3188 3188
                if(  (avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type==B_TYPE)
3189 3189
                    ||(avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type!=I_TYPE)
3190 3190
                    || avctx->skip_frame >= AVDISCARD_ALL)
3191 3191
                    break;
3192
                /* skip everything if we are in a hurry>=5 */
3192
                /* Skip everything if we are in a hurry>=5. */
3193 3193
                if(avctx->hurry_up>=5) break;
3194 3194

  
3195 3195
                if (!s->mpeg_enc_ctx_allocated) break;
libavcodec/mpegaudioenc.c
470 470
            sf[1] = sf[2] = sf[0];
471 471
            break;
472 472
        default:
473
            assert(0); //cant happen
473
            assert(0); //cannot happen
474 474
            code = 0;           /* kill warning */
475 475
        }
476 476

  
libavcodec/mpegvideo.c
372 372
 * The pixels are allocated/set by calling get_buffer() if shared=0
373 373
 */
374 374
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
375
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
375
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
376 376
    const int mb_array_size= s->mb_stride*s->mb_height;
377 377
    const int b8_array_size= s->b8_stride*s->mb_height*2;
378 378
    const int b4_array_size= s->b4_stride*s->mb_height*4;
......
492 492
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
493 493
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
494 494

  
495
     //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
495
     //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
496 496
    CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t))
497 497
    s->rd_scratchpad=   s->me.scratchpad;
498 498
    s->b_scratchpad=    s->me.scratchpad;
......
1633 1633
    s->error_resilience= avctx->error_resilience;
1634 1634

  
1635 1635
    /* set dequantizer, we can't do it during init as it might change for mpeg4
1636
       and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1636
       and we can't do it in the header decode as init is not called for mpeg4 there yet */
1637 1637
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1638 1638
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1639 1639
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
libavcodec/mpegvideo.h
133 133
#define IS_ACPRED(a)     ((a)&MB_TYPE_ACPRED)
134 134
#define IS_QUANT(a)      ((a)&MB_TYPE_QUANT)
135 135
#define IS_DIR(a, part, list) ((a) & (MB_TYPE_P0L0<<((part)+2*(list))))
136
#define USES_LIST(a, list) ((a) & ((MB_TYPE_P0L0|MB_TYPE_P1L0)<<(2*(list)))) ///< does this mb use listX, note doesnt work if subMBs
136
#define USES_LIST(a, list) ((a) & ((MB_TYPE_P0L0|MB_TYPE_P1L0)<<(2*(list)))) ///< does this mb use listX, note does not work if subMBs
137 137
#define HAS_CBP(a)        ((a)&MB_TYPE_CBP)
138 138

  
139 139
    int field_poc[2];           ///< h264 top/bottom POC
......
161 161
typedef struct MotionEstContext{
162 162
    AVCodecContext *avctx;
163 163
    int skip;                          ///< set if ME is skipped for the current MB
164
    int co_located_mv[4][2];           ///< mv from last p frame for direct mode ME
164
    int co_located_mv[4][2];           ///< mv from last P-frame for direct mode ME
165 165
    int direct_basis_mv[4][2];
166
    uint8_t *scratchpad;               ///< data area for the me algo, so that the ME doesnt need to malloc/free
166
    uint8_t *scratchpad;               ///< data area for the ME algo, so that the ME does not need to malloc/free
167 167
    uint8_t *best_mb;
168 168
    uint8_t *temp_mb[2];
169 169
    uint8_t *temp;
......
248 248

  
249 249
    /* sequence parameters */
250 250
    int context_initialized;
251
    int input_picture_number;  ///< used to set pic->display_picture_number, shouldnt be used for/by anything else
252
    int coded_picture_number;  ///< used to set pic->coded_picture_number, shouldnt be used for/by anything else
251
    int input_picture_number;  ///< used to set pic->display_picture_number, should not be used for/by anything else
252
    int coded_picture_number;  ///< used to set pic->coded_picture_number, should not be used for/by anything else
253 253
    int picture_number;       //FIXME remove, unclear definition
254 254
    int picture_in_gop_number; ///< 0-> first pic in gop, ...
255 255
    int b_frames_since_non_b;  ///< used for encoding, relative to not yet reordered input
libavcodec/msmpeg4.c
1006 1006
            /* luminance h263 */
1007 1007
            uni_code= DCtab_lum[size][0];
1008 1008
            uni_len = DCtab_lum[size][1];
1009
            uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1009
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1010 1010

  
1011 1011
            if (size > 0) {
1012 1012
                uni_code<<=size; uni_code|=l;
......
1022 1022
            /* chrominance h263 */
1023 1023
            uni_code= DCtab_chrom[size][0];
1024 1024
            uni_len = DCtab_chrom[size][1];
1025
            uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1025
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1026 1026

  
1027 1027
            if (size > 0) {
1028 1028
                uni_code<<=size; uni_code|=l;
......
1132 1132
        break;
1133 1133
    }
1134 1134

  
1135
    s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1135
    s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1136 1136

  
1137 1137
    return 0;
1138 1138
}
libavcodec/os2thread.c
62 62

  
63 63
/**
64 64
 * free what has been allocated by avcodec_thread_init().
65
 * must be called after decoding has finished, especially dont call while avcodec_thread_execute() is running
65
 * must be called after decoding has finished, especially do not call while avcodec_thread_execute() is running
66 66
 */
67 67
void avcodec_thread_free(AVCodecContext *s){
68 68
    ThreadContext *c= s->thread_opaque;
libavcodec/ratecontrol.c
160 160

  
161 161
            next= strchr(p, ';');
162 162
            if(next){
163
                (*next)=0; //sscanf in unbelieavle slow on looong strings //FIXME copy / dont write
163
                (*next)=0; //sscanf in unbelievably slow on looong strings //FIXME copy / do not write
164 164
                next++;
165 165
            }
166 166
            e= sscanf(p, " in:%d ", &picture_number);
......
396 396
        else if(q < last_q - maxdiff) q= last_q - maxdiff;
397 397
    }
398 398

  
399
    rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring
399
    rcc->last_qscale_for[pict_type]= q; //Note we cannot do that after blurring
400 400

  
401 401
    if(pict_type!=B_TYPE)
402 402
        rcc->last_non_b_pict_type= pict_type;
......
605 605
        bits_tab[i]= bits;
606 606
    }
607 607

  
608
    /* handle qmin/qmax cliping */
608
    /* handle qmin/qmax clipping */
609 609
    if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
610 610
        float factor= bits_sum/cplx_sum;
611 611
        for(i=0; i<s->mb_num; i++){
libavcodec/snow.c
2112 2112
            my= ref_my;
2113 2113
        }
2114 2114
    }
2115
    //FIXME if mb_cmp != SSE then intra cant be compared currently and mb_penalty vs. lambda2
2115
    //FIXME if mb_cmp != SSE then intra cannot be compared currently and mb_penalty vs. lambda2
2116 2116

  
2117 2117
  //  subpel search
2118 2118
    base_bits= get_rac_count(&s->c) - 8*(s->c.bytestream - s->c.bytestream_start);
......
2892 2892
    }
2893 2893
    *b= backup;
2894 2894

  
2895
    return av_clip(((ab<<LOG2_OBMC_MAX) + aa/2)/aa, 0, 255); //FIXME we shouldnt need cliping
2895
    return av_clip(((ab<<LOG2_OBMC_MAX) + aa/2)/aa, 0, 255); //FIXME we should not need clipping
2896 2896
}
2897 2897

  
2898 2898
static inline int get_block_bits(SnowContext *s, int x, int y, int w){
......
3276 3276
                for(i=0; i<3; i++)
3277 3277
                    color[i]= get_dc(s, mb_x, mb_y, i);
3278 3278

  
3279
                // get previous score (cant be cached due to OBMC)
3279
                // get previous score (cannot be cached due to OBMC)
3280 3280
                if(pass > 0 && (block->type&BLOCK_INTRA)){
3281 3281
                    int color0[3]= {block->color[0], block->color[1], block->color[2]};
3282 3282
                    check_block(s, mb_x, mb_y, color0, 1, *obmc_edged, &best_rd);
libavcodec/svq1.c
499 499
    int mvx= pmv[i]->x + (i&1)*16;
500 500
    int mvy= pmv[i]->y + (i>>1)*16;
501 501

  
502
    ///XXX /FIXME cliping or padding?
502
    ///XXX /FIXME clipping or padding?
503 503
    if(y + (mvy >> 1)<0)
504 504
       mvy= 0;
505 505
    if(x + (mvx >> 1)<0)
libavcodec/svq3.c
891 891
  s->current_picture.pict_type = s->pict_type;
892 892
  s->current_picture.key_frame = (s->pict_type == I_TYPE);
893 893

  
894
  /* skip b frames if we dont have reference frames */
894
  /* Skip B-frames if we do not have reference frames. */
895 895
  if (s->last_picture_ptr == NULL && s->pict_type == B_TYPE) return 0;
896
  /* skip b frames if we are in a hurry */
896
  /* Skip B-frames if we are in a hurry. */
897 897
  if (avctx->hurry_up && s->pict_type == B_TYPE) return 0;
898
  /* skip everything if we are in a hurry >= 5 */
898
  /* Skip everything if we are in a hurry >= 5. */
899 899
  if (avctx->hurry_up >= 5) return 0;
900 900
  if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
901 901
     ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
......
993 993

  
994 994
  avctx->frame_number = s->picture_number - 1;
995 995

  
996
  /* dont output the last pic after seeking */
996
  /* Do not output the last pic after seeking. */
997 997
  if (s->last_picture_ptr || s->low_delay) {
998 998
    *data_size = sizeof(AVFrame);
999 999
  }
libavcodec/utils.c
273 273
        pixel_size= picture.linesize[0]*8 / w;
274 274
//av_log(NULL, AV_LOG_ERROR, "%d %d %d %d\n", (int)picture.data[1], w, h, s->pix_fmt);
275 275
        assert(pixel_size>=1);
276
            //FIXME next ensures that linesize= 2^x uvlinesize, thats needed because some MC code assumes it
276
            //FIXME next ensures that linesize= 2^x uvlinesize, that is needed because some MC code assumes it
277 277
        if(pixel_size == 3*8)
278 278
            w= ALIGN(w, STRIDE_ALIGN<<h_chroma_shift);
279 279
        else
......
402 402
}
403 403

  
404 404
#define OFFSET(x) offsetof(AVCodecContext,x)
405
#define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
405
#define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
406 406
//these names are too long to be readable
407 407
#define V AV_OPT_FLAG_VIDEO_PARAM
408 408
#define A AV_OPT_FLAG_AUDIO_PARAM
......
1357 1357
static AbvEntry frame_abvs[] = {
1358 1358
    { "ntsc",      720, 480, 30000, 1001 },
1359 1359
    { "pal",       720, 576,    25,    1 },
1360
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
1361
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
1360
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant NTSC */
1361
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant PAL */
1362 1362
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel NTSC */
1363 1363
    { "spal",      768, 576,    25,    1 }, /* square pixel PAL */
1364 1364
    { "film",      352, 240,    24,    1 },
libavcodec/vc1.c
4012 4012
        return 0;
4013 4013
    }
4014 4014

  
4015
    //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
4015
    /* We need to set current_picture_ptr before reading the header,
4016
     * otherwise we cannot store anyting in there. */
4016 4017
    if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
4017 4018
        int i= ff_find_unused_picture(s, 0);
4018 4019
        s->current_picture_ptr= &s->picture[i];
libavcodec/vorbis_enc.c
756 756
                    int maxval = 1;
757 757
                    if (c->books[l] != -1)
758 758
                        maxval = venc->codebooks[c->books[l]].nentries;
759
                    // coded could be -1, but this still works, cause thats 0
759
                    // coded could be -1, but this still works, cause that is 0
760 760
                    if (coded[counter + k] < maxval) break;
761 761
                }
762 762
                assert(l != csub);
libavcodec/w32thread.c
56 56
}
57 57

  
58 58
/**
59
 * free what has been allocated by avcodec_thread_init().
60
 * must be called after decoding has finished, especially dont call while avcodec_thread_execute() is running
59
 * Free what has been allocated by avcodec_thread_init().
60
 * Must be called after decoding has finished, especially do not call while avcodec_thread_execute() is running.
61 61
 */
62 62
void avcodec_thread_free(AVCodecContext *s){
63 63
    ThreadContext *c= s->thread_opaque;
libavcodec/wmv2.c
194 194
    return 0;
195 195
}
196 196

  
197
// nearly idential to wmv1 but thats just because we dont use the useless M$ crap features
198
// its duplicated here in case someone wants to add support for these carp features
197
/* Nearly identical to wmv1 but that is just because we do not use the
198
 * useless M$ crap features. It is duplicated here in case someone wants
199
 * to add support for these crap features. */
199 200
void ff_wmv2_encode_mb(MpegEncContext * s,
200 201
                       DCTELEM block[6][64],
201 202
                       int motion_x, int motion_y)
libavformat/asf.c
413 413

  
414 414
                get_str16_nolen(pb, name_len, name, sizeof(name));
415 415
//av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d <%s>\n", i, stream_num, name_len, value_type, value_len, name);
416
                value_num= get_le16(pb);//we should use get_value() here but it doesnt work 2 is le16 here but le32 elsewhere
416
                value_num= get_le16(pb);//we should use get_value() here but it does not work 2 is le16 here but le32 elsewhere
417 417
                url_fskip(pb, value_len - 2);
418 418

  
419 419
                if(stream_num<128){
libavformat/avformat.h
158 158
#define AVFMT_RAWPICTURE    0x0020 /**< format wants AVPicture structure for
159 159
                                      raw picture data */
160 160
#define AVFMT_GLOBALHEADER  0x0040 /**< format wants global header */
161
#define AVFMT_NOTIMESTAMPS  0x0080 /**< format doesnt need / has any timestamps */
161
#define AVFMT_NOTIMESTAMPS  0x0080 /**< format does not need / have any timestamps */
162 162
#define AVFMT_GENERIC_INDEX 0x0100 /**< use generic index building code */
163 163

  
164 164
typedef struct AVOutputFormat {
......
295 295
    int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */
296 296
    /* ffmpeg.c private use */
297 297
    int stream_copy; /**< if set, just copy stream */
298
    enum AVDiscard discard; ///< selects which packets can be discarded at will and dont need to be demuxed
298
    enum AVDiscard discard; ///< selects which packets can be discarded at will and do not need to be demuxed
299 299
    //FIXME move stuff to a flags field?
300 300
    /** quality, as it has been removed from AVCodecContext and put in AVVideoFrame
301
     * MN:dunno if thats the right place, for it */
301
     * MN: dunno if that is the right place for it */
302 302
    float quality;
303 303
    /** decoding: pts of the first frame of the stream, in stream time base. */
304 304
    int64_t start_time;
......
546 546
 *
547 547
 * @param ic media file handle
548 548
 * @return >=0 if OK. AVERROR_xxx if error.
549
 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
549
 * @todo Let user decide somehow what information is needed so we do not waste time geting stuff the user does not need.
550 550
 */
551 551
int av_find_stream_info(AVFormatContext *ic);
552 552

  
......
666 666

  
667 667
/**
668 668
 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
669
 * this isnt supposed to be called directly by a user application, but by demuxers
669
 * This is not supposed to be called directly by a user application, but by demuxers.
670 670
 * @param target_ts target timestamp in the time base of the given stream
671 671
 * @param stream_index stream number
672 672
 */
......
676 676
 * Updates cur_dts of all streams based on given timestamp and AVStream.
677 677
 *
678 678
 * Stream ref_st unchanged, others set cur_dts in their native timebase
679
 * only needed for timestamp wrapping or if (dts not set and pts!=dts)
679
 * only needed for timestamp wrapping or if (dts not set and pts!=dts).
680 680
 * @param timestamp new dts expressed in time_base of param ref_st
681 681
 * @param ref_st reference stream giving time_base of param timestamp
682 682
 */
......
684 684

  
685 685
/**
686 686
 * Does a binary search using read_timestamp().
687
 * this isnt supposed to be called directly by a user application, but by demuxers
687
 * This is not supposed to be called directly by a user application, but by demuxers.
688 688
 * @param target_ts target timestamp in the time base of the given stream
689 689
 * @param stream_index stream number
690 690
 */
......
694 694
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap);
695 695

  
696 696
/**
697
 * allocate the stream private data and write the stream header to an
698
 * output media file
697
 * Allocate the stream private data and write the stream header to an
698
 * output media file.
699 699
 *
700 700
 * @param s media file handle
701 701
 * @return 0 if OK. AVERROR_xxx if error.
libavformat/flvenc.c
69 69
            flags |= FLV_SAMPLERATE_SPECIAL;
70 70
            break;
71 71
        default:
72
            av_log(enc, AV_LOG_ERROR, "flv doesnt support that sample rate, choose from (44100, 22050, 11025)\n");
72
            av_log(enc, AV_LOG_ERROR, "flv does not support that sample rate, choose from (44100, 22050, 11025).\n");
73 73
            return -1;
74 74
    }
75 75

  
libavformat/mov.c
751 751
                break;
752 752
            }
753 753

  
754
            //Read QT version 1 fields. In version 0 theese dont exist
754
            //Read QT version 1 fields. In version 0 these do not exist.
755 755
            dprintf(c->fc, "version =%d, isom =%d\n",version,c->isom);
756 756
            if(!c->isom) {
757 757
                if(version==1) {
......
1423 1423
    }
1424 1424

  
1425 1425
    for(i=0; i<mov->total_streams; i++) {
1426
        /* dont need those anymore */
1426
        /* Do not need those anymore. */
1427 1427
        av_freep(&mov->streams[i]->chunk_offsets);
1428 1428
        av_freep(&mov->streams[i]->sample_to_chunk);
1429 1429
        av_freep(&mov->streams[i]->sample_sizes);
libavformat/movenc.c
1182 1182
    /* iTunes meta data */
1183 1183
    mov_write_meta_tag(pb, mov, s);
1184 1184

  
1185
  if(mov->mode == MODE_MOV){ // the title field breaks gtkpod with mp4 and my suspicion is that stuff isnt valid in mp4
1185
  if(mov->mode == MODE_MOV){ // the title field breaks gtkpod with mp4 and my suspicion is that stuff is not valid in mp4
1186 1186
    /* Requirements */
1187 1187
    for (i=0; i<mov->nb_streams; i++) {
1188 1188
        if(mov->tracks[i].entry <= 0) continue;
libavformat/mpeg.c
822 822

  
823 823
        stuffing_size = payload_size - av_fifo_size(&stream->fifo);
824 824

  
825
        // first byte doesnt fit -> reset pts/dts + stuffing
825
        // first byte does not fit -> reset pts/dts + stuffing
826 826
        if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
827 827
            int timestamp_len=0;
828 828
            if(dts != pts)
libavformat/nsvdec.c
91 91
struct NSVf_header {
92 92
    uint32_t chunk_tag; /* 'NSVf' */
93 93
    uint32_t chunk_size;
94
    uint32_t file_size; /* max 4GB ??? noone learns anything it seems :^) */
94
    uint32_t file_size; /* max 4GB ??? no one learns anything it seems :^) */
95 95
    uint32_t file_length; //unknown1;  /* what about MSB of file_size ? */
96 96
    uint32_t info_strings_size; /* size of the info strings */ //unknown2;
97 97
    uint32_t table_entries;
......
197 197
    { CODEC_ID_VP4, MKTAG('V', 'P', '4', ' ') },
198 198
    { CODEC_ID_VP4, MKTAG('V', 'P', '4', '0') },
199 199
*/
200
    { CODEC_ID_XVID, MKTAG('X', 'V', 'I', 'D') }, /* cf sample xvid decoder from nsv_codec_sdk.zip */
200
    { CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') }, /* cf sample xvid decoder from nsv_codec_sdk.zip */
201 201
    { CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', '3') },
202 202
    { 0, 0 },
203 203
};
libavformat/nut.c
85 85
    int64_t packet_start[3]; //0-> startcode less, 1-> short startcode 2-> long startcodes
86 86
    FrameCode frame_code[256];
87 87
    unsigned int stream_count;
88
    uint64_t next_startcode;     ///< stores the next startcode if it has alraedy been parsed but the stream isnt seekable
88
    uint64_t next_startcode;     ///< stores the next startcode if it has already been parsed but the stream is not seekable
89 89
    StreamContext *stream;
90 90
    int max_distance;
91 91
    int max_short_distance;
......
359 359
    uint64_t state=0;
360 360

  
361 361
    if(pos >= 0)
362
        url_fseek(bc, pos, SEEK_SET); //note, this may fail if the stream isnt seekable, but that shouldnt matter, as in this case we simply start where we are currently
362
        url_fseek(bc, pos, SEEK_SET); //note, this may fail if the stream is not seekable, but that should not matter, as in this case we simply start where we are currently
363 363

  
364 364
    while(!url_feof(bc)){
365 365
        state= (state<<8) | get_byte(bc);
libavformat/nut.h
63 63
    uint16_t size_lsb;
64 64
    int16_t  pts_delta;
65 65
    uint8_t  reserved_count;
66
} FrameCode; // maybe s/FrameCode/framecode_t/ or change all to java style but dont mix
66
} FrameCode; // maybe s/FrameCode/framecode_t/ or change all to Java style but do not mix
67 67

  
68 68
typedef struct {
69 69
    int last_flags;
......
81 81
//    int written_packet_size;
82 82
//    int64_t packet_start[3]; //0-> startcode less, 1-> short startcode 2-> long startcodes
83 83
    FrameCode frame_code[256];
84
    uint64_t next_startcode;     ///< stores the next startcode if it has alraedy been parsed but the stream isnt seekable
84
    uint64_t next_startcode;     ///< stores the next startcode if it has already been parsed but the stream is not seekable
85 85
    StreamContext *stream;
86 86
    unsigned int max_distance;
87 87
    unsigned int time_base_count;
libavformat/nutdec.c
116 116
    uint64_t state=0;
117 117

  
118 118
    if(pos >= 0)
119
        url_fseek(bc, pos, SEEK_SET); //note, this may fail if the stream isnt seekable, but that shouldnt matter, as in this case we simply start where we are currently
119
        url_fseek(bc, pos, SEEK_SET); //note, this may fail if the stream is not seekable, but that should not matter, as in this case we simply start where we are currently
120 120

  
121 121
    while(!url_feof(bc)){
122 122
        state= (state<<8) | get_byte(bc);
......
836 836
                                                next_node[0]->back_ptr, next_node[1]->back_ptr, flags, &ts, nut_read_timestamp);
837 837
            if(pos2>=0)
838 838
                pos= pos2;
839
            //FIXME dir but i think it doesnt matter
839
            //FIXME dir but i think it does not matter
840 840
        }
841 841
        dummy.pos= pos;
842 842
        sp= av_tree_find(nut->syncpoints, &dummy, sp_pos_cmp, NULL);
libavformat/raw.c
316 316
    st->need_parsing = AVSTREAM_PARSE_FULL;
317 317

  
318 318
    /* for mjpeg, specify frame rate */
319
    /* for mpeg4 specify it too (most mpeg4 streams dont have the fixed_vop_rate set ...)*/
319
    /* for mpeg4 specify it too (most mpeg4 streams do not have the fixed_vop_rate set ...)*/
320 320
    if (ap->time_base.num) {
321 321
        av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
322 322
    } else if ( st->codec->codec_id == CODEC_ID_MJPEG ||
libavformat/riff.c
329 329
    }
330 330

  
331 331
    if (enc->codec_id == CODEC_ID_MP2 || enc->codec_id == CODEC_ID_MP3 || enc->codec_id == CODEC_ID_GSM_MS) {
332
        blkalign = enc->frame_size; //this is wrong, but seems many demuxers dont work if this is set correctly
332
        blkalign = enc->frame_size; //this is wrong, but it seems many demuxers do not work if this is set correctly
333 333
        //blkalign = 144 * enc->bit_rate/enc->sample_rate;
334 334
    } else if (enc->codec_id == CODEC_ID_ADPCM_G726) { //
335 335
        blkalign = 1;
libavformat/rtp.c
515 515
    infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
516 516

  
517 517
    /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
518
       In my test, the faad decoder doesnt behave correctly when sending each AU one by one
518
       In my test, the FAAD decoder does not behave correctly when sending each AU one by one
519 519
       but does when sending the whole as one big packet...  */
520 520
    infos->au_headers[0].size = 0;
521 521
    infos->au_headers[0].index = 0;
libavformat/swf.c
386 386
            break;
387 387
        default:
388 388
            /* not supported */
389
            av_log(s, AV_LOG_ERROR, "swf doesnt support that sample rate, choose from (44100, 22050, 11025)\n");
389
            av_log(s, AV_LOG_ERROR, "swf does not support that sample rate, choose from (44100, 22050, 11025).\n");
390 390
            return -1;
391 391
        }
392 392
        v |= 0x02; /* 16 bit playback */
libavformat/utils.c
293 293
}
294 294

  
295 295
#define OFFSET(x) offsetof(AVFormatContext,x)
296
#define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
296
#define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
297 297
//these names are too long to be readable
298 298
#define E AV_OPT_FLAG_ENCODING_PARAM
299 299
#define D AV_OPT_FLAG_DECODING_PARAM
......
632 632
    if (delay &&
633 633
        pc && pc->pict_type != FF_B_TYPE)
634 634
        presentation_delayed = 1;
635
    /* this may be redundant, but it shouldnt hurt */
635
    /* This may be redundant, but it should not hurt. */
636 636
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
637 637
        presentation_delayed = 1;
638 638

  
......
992 992
                return -1;
993 993
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
994 994
            st->nb_index_entries++;
995
        }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
995
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
996 996
            distance= ie->min_distance;
997 997
    }
998 998

  
libpostproc/postprocess.c
47 47
MedianDeinterlace#      E       Ec      Ec
48 48
TempDeNoiser#           E               e       e       Ec
49 49

  
50
* i dont have a 3dnow CPU -> its untested, but noone said it doesnt work so it seems to work
51
# more or less selfinvented filters so the exactness isnt too meaningfull
50
* i do not have a 3DNow! CPU -> it is untested, but no one said it does not work so it seems to work
51
# more or less selfinvented filters so the exactness is not too meaningful
52 52
E = Exact implementation
53 53
e = allmost exact implementation (slightly different rounding,...)
54 54
a = alternative / approximate impl
......
398 398
 * Experimental Filter 1 (Horizontal)
399 399
 * will not damage linear gradients
400 400
 * Flat blocks should look like they where passed through the (1,1,2,2,4,2,2,1,1) 9-Tap filter
401
 * can only smooth blocks at the expected locations (it cant smooth them if they did move)
402
 * MMX2 version does correct clipping C version doesnt
401
 * can only smooth blocks at the expected locations (it cannot smooth them if they did move)
402
 * MMX2 version does correct clipping C version does not
403 403
 * not identical with the vertical one
404 404
 */
405 405
static inline void horizX1Filter(uint8_t *src, int stride, int QP)
......
646 646
#include "postprocess_template.c"
647 647
#endif
648 648

  
649
// minor note: the HAVE_xyz is messed up after that line so dont use it
649
// minor note: the HAVE_xyz is messed up after that line so do not use it.
650 650

  
651 651
static inline void postProcess(uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
652 652
        QP_STORE_T QPs[], int QPStride, int isColor, pp_mode_t *vm, pp_context_t *vc)
......
655 655
        PPMode *ppMode= (PPMode *)vm;
656 656
        c->ppMode= *ppMode; //FIXME
657 657

  
658
        // useing ifs here as they are faster than function pointers allthough the
659
        // difference wouldnt be messureable here but its much better because
660
        // someone might exchange the cpu whithout restarting mplayer ;)
658
        // Using ifs here as they are faster than function pointers although the
659
        // difference would not be measureable here but it is much better because
660
        // someone might exchange the CPU whithout restarting MPlayer ;)
661 661
#ifdef RUNTIME_CPUDETECT
662 662
#if defined(ARCH_X86)
663 663
        // ordered per speed fasterst first
......
961 961

  
962 962
        for(i=0; i<3; i++)
963 963
        {
964
                //Note:the +17*1024 is just there so i dont have to worry about r/w over te end
964
                //Note: The +17*1024 is just there so i do not have to worry about r/w over the end.
965 965
                reallocAlign((void **)&c->tempBlured[i], 8, stride*mbHeight*16 + 17*1024);
966 966
                reallocAlign((void **)&c->tempBluredPast[i], 8, 256*((height+7)&(~7))/2 + 17*1024);//FIXME size
967 967
        }
libpostproc/postprocess_internal.h
66 66
#    define PIC
67 67
#endif
68 68

  
69
//use if u want a faster postprocessing code
70
//cant differentiate between chroma & luma filters (both on or both off)
71
//obviosly the -pp option at the commandline has no effect except turning the here selected
69
//use if you want a faster postprocessing code
70
//cannot differentiate between chroma & luma filters (both on or both off)
71
//obviously the -pp option on the command line has no effect except turning the here selected
72 72
//filters on
73 73
//#define COMPILE_TIME_MODE 0x77
74 74

  
libpostproc/postprocess_template.c
73 73
        "paddb " #a ", " #b " \n\t"
74 74
#endif
75 75

  
76
//FIXME? |255-0| = 1 (shouldnt be a problem ...)
76
//FIXME? |255-0| = 1 (should not be a problem ...)
77 77
#ifdef HAVE_MMX
78 78
/**
79 79
 * Check if the middle 8x8 Block in the given 8x16 block is flat
......
478 478
 * Experimental Filter 1
479 479
 * will not damage linear gradients
480 480
 * Flat blocks should look like they where passed through the (1,1,2,2,4,2,2,1,1) 9-Tap filter
481
 * can only smooth blocks at the expected locations (it cant smooth them if they did move)
482
 * MMX2 version does correct clipping C version doesnt
481
 * can only smooth blocks at the expected locations (it cannot smooth them if they did move)
482
 * MMX2 version does correct clipping C version does not
483 483
 */
484 484
static inline void RENAME(vertX1Filter)(uint8_t *src, int stride, PPContext *co)
485 485
{
......
3183 3183
        QP_STORE_T QPs[], int QPStride, int isColor, PPContext *c);
3184 3184

  
3185 3185
/**
3186
 * Copies a block from src to dst and fixes the blacklevel
3187
 * levelFix == 0 -> dont touch the brighness & contrast
3186
 * Copies a block from src to dst and fixes the blacklevel.
3187
 * levelFix == 0 -> do not touch the brighness & contrast
3188 3188
 */
3189 3189
#undef SCALED_CPY
3190 3190

  
output_example.c
217 217
        c->max_b_frames = 2;
218 218
    }
219 219
    if (c->codec_id == CODEC_ID_MPEG1VIDEO){
220
        /* needed to avoid using macroblocks in which some coeffs overflow
221
           this doesnt happen with normal video, it just happens here as the
222
           motion of the chroma plane doesnt match the luma plane */
220
        /* Needed to avoid using macroblocks in which some coeffs overflow.
221
           This does not happen with normal video, it just happens here as
222
           the motion of the chroma plane does not match the luma plane. */
223 223
        c->mb_decision=2;
224 224
    }
225 225
    // some formats want stream headers to be separate
pktdumper.c
46 46
    AVPacket pkt;
47 47
    int64_t pktnum = 0;
48 48
    int64_t maxpkts = 0;
49
    int dontquit = 0;
49
    int donotquit = 0;
50 50
    int nowrite = 0;
51 51
    int err;
52 52

  
53 53
    if ((argc > 1) && !strncmp(argv[1], "-", 1)) {
54 54
        if (strchr(argv[1], 'w'))
55
            dontquit = 1;
55
            donotquit = 1;
56 56
        if (strchr(argv[1], 'n'))
57 57
            nowrite = 1;
58 58
        argv++;
......
110 110
            break;
111 111
    }
112 112

  
113
    while (dontquit)
113
    while (donotquit)
114 114
        sleep(60);
115 115

  
116 116
    return 0;
tests/seek_test.c
52 52

  
53 53
    ret = av_open_input_file(&ic, filename, NULL, 0, NULL);
54 54
    if (ret < 0) {
55
        fprintf(stderr, "cant open %s\n", filename);
55
        fprintf(stderr, "cannot open %s\n", filename);
56 56
        exit(1);
57 57
    }
58 58

  

Also available in: Unified diff