- macroblock based pixel format (better cache locality, somewhat complex, one paper claimed it faster for high res)
- NUT muxer
- seeking regression test
-- regression tests for codecs which dont have an encoder (I+P frame bitstream in svn)
+- regression tests for codecs which do not have an encoder (I+P-frame bitstream in svn)
- add support for using mplayers video filters to ffmpeg
- reverse engeneer RV30/RV40
- finish implementation of WMV2 j-picture
* Modular (few interdependencies and the possibility of disabling individual parts during ./configure)
* Small (source and object)
* Efficient (low CPU and memory usage)
-* Useful (avoid useless features almost noone needs)
+* Useful (avoid useless features almost no one needs)
list, reference the thread in the log message.
@item
Do NOT commit to code actively maintained by others without permission.
- Send a patch to ffmpeg-devel instead. If noone answers within a reasonable
+ Send a patch to ffmpeg-devel instead. If no one answers within a reasonable
timeframe (12h for build failures and security fixes, 3 days small changes,
1 week for big patches) then commit your patch if you think it is OK.
Also note, the maintainer can simply ask for more time to review!
}
printf("\n\n");
printf(
-"Note, the names of encoders and decoders dont always match, so there are\n"
+"Note, the names of encoders and decoders do not always match, so there are\n"
"several cases where the above table shows encoder only or decoder only entries\n"
-"even though both encoding and decoding are supported for example, the h263\n"
-"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
-"worse\n");
+"even though both encoding and decoding are supported. For example, the h263\n"
+"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
+"worse.\n");
exit(1);
}
ret = -1;
goto fail;
}
- ic->pb.eof_reached= 0; //FIXME hack, ffplay maybe shouldnt use url_feof() to test for the end
+ ic->pb.eof_reached= 0; //FIXME hack, ffplay maybe should not use url_feof() to test for the end
}
/* if seeking requested, we execute it */
}
}
- /* If already streaming this feed, dont let start an another feeder */
+ /* If already streaming this feed, do not let start another feeder. */
if (stream->feed_opened) {
snprintf(msg, sizeof(msg), "This feed is already being received.");
goto send_error;
picture= avcodec_alloc_frame();
if(codec->capabilities&CODEC_CAP_TRUNCATED)
- c->flags|= CODEC_FLAG_TRUNCATED; /* we dont send complete frames */
+ c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
- /* for some codecs, such as msmpeg4 and mpeg4, width and height
- MUST be initialized there because these info are not available
- in the bitstream */
+ /* For some codecs, such as msmpeg4 and mpeg4, width and height
+ MUST be initialized there because this information is not
+ available in the bitstream. */
/* open it */
if (avcodec_open(c, codec) < 0) {
}while(po < end);\
}
-//FIXME put things below under ifdefs so we dont waste space for cases no codec will need
-//FIXME rounding and cliping ?
+//FIXME put things below under ifdefs so we do not waste space for cases no codec will need
+//FIXME rounding and clipping ?
CONV(SAMPLE_FMT_U8 , uint8_t, SAMPLE_FMT_U8 , *(uint8_t*)pi)
else CONV(SAMPLE_FMT_S16, int16_t, SAMPLE_FMT_U8 , (*(uint8_t*)pi - 0x80)<<8)
/**
* Parses \p str and put in \p width_ptr and \p height_ptr the detected values.
*
- * @return 0 in case of a successfull parsing, a negative value otherwise
+ * @return 0 in case of a successful parsing, a negative value otherwise
* @param[in] str the string to parse: it has to be a string in the format
* <width>x<height> or a valid video frame size abbreviation.
* @param[in,out] width_ptr pointer to the variable which will contain the detected
/**
* Parses \p str and put in \p frame_rate the detected values.
*
- * @return 0 in case of a successfull parsing, a negative value otherwise
+ * @return 0 in case of a successful parsing, a negative value otherwise
* @param[in] str the string to parse: it has to be a string in the format
* <frame_rate_nom>/<frame_rate_den>, a float number or a valid video rate abbreviation
* @param[in,out] frame_rate pointer to the AVRational which will contain the detected
}
/**
- * free what has been allocated by avcodec_thread_init().
- * must be called after decoding has finished, especially dont call while avcodec_thread_execute() is running
+ * Free what has been allocated by avcodec_thread_init().
+ * Must be called after decoding has finished, especially do not call while avcodec_thread_execute() is running.
*/
void avcodec_thread_free(AVCodecContext *s){
ThreadContext *c= s->thread_opaque;
}
/**
- * skips the given number of bits.
- * must only be used if the actual values in the bitstream dont matter
+ * Skips the given number of bits.
+ * Must only be used if the actual values in the bitstream do not matter.
*/
static inline void skip_put_bits(PutBitContext *s, int n){
#ifdef ALT_BITSTREAM_WRITER
}
//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!)
-//FIXME use some macros to avoid duplicatin get_cabac (cant be done yet as that would make optimization work hard)
+//FIXME use some macros to avoid duplicatin get_cabac (cannot be done yet as that would make optimization work hard)
#if defined(ARCH_X86) && defined(CONFIG_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS)
static int decode_significance_x86(CABACContext *c, int max_coeff, uint8_t *significant_coeff_ctx_base, int *index){
void *end= significant_coeff_ctx_base + max_coeff - 1;
for(i=0; i<64; i++)
block[i]= block1[i];
// memcpy(block, block1, sizeof(DCTELEM) * 64);
-// dont memcpy especially not fastmemcpy because it does movntq !!!
+// do not memcpy especially not fastmemcpy because it does movntq !!!
fdct_func(block);
}
it1 += NB_ITS_SPEED;
for(i=0; i<64; i++)
block[i]= block1[i];
// memcpy(block, block1, sizeof(DCTELEM) * 64);
-// dont memcpy especially not fastmemcpy because it does movntq !!!
+// do not memcpy especially not fastmemcpy because it does movntq !!!
idct248_put(img_dest, 8, block);
}
it1 += NB_ITS_SPEED;
/* motion estimation */
// h is limited to {width/2, width, 2*width} but never larger than 16 and never smaller then 2
-// allthough currently h<4 is not used as functions with width <8 are not used and neither implemented
+// although currently h<4 is not used as functions with width <8 are neither used nor implemented
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))*/;
}
/**
- * guess the dc of blocks which dont have a undamaged dc
+ * guess the dc of blocks which do not have an undamaged dc
* @param w width in 8 pixel blocks
* @param h height in 8 pixel blocks
*/
}
/* Now FLX is strange, in that it is "byte" as opposed to "pixel" run length compressed.
- * This doesnt give us any good oportunity to perform word endian conversion
- * during decompression. So if its requried (ie, this isnt a LE target, we do
+ * This does not give us any good oportunity to perform word endian conversion
+ * during decompression. So if it is required (i.e., this is not a LE target, we do
* a second pass over the line here, swapping the bytes.
*/
pixel = 0xFF00;
buf, buf_size);
}
- /* Shouldnt get here, ever as the pix_fmt is processed */
+ /* Should not get here, ever as the pix_fmt is processed */
/* in flic_decode_init and the above if should deal with */
/* the finite set of possibilites allowable by here. */
- /* but in case we do, just error out. */
- av_log(avctx, AV_LOG_ERROR, "Unknown Format of FLC. My Science cant explain how this happened\n");
+ /* But in case we do, just error out. */
+ av_log(avctx, AV_LOG_ERROR, "Unknown FLC format, my science cannot explain how this happened.\n");
return -1;
}
*/
static int get_consumed_bytes(MpegEncContext *s, int buf_size){
int pos= get_bits_count(&s->gb)>>3;
- if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
+ if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)
if(pos+10>buf_size) pos=buf_size; // oops ;)
return pos;
return -1;
}
- //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
+ //we need to set current_picture_ptr before reading the header, otherwise we cannot store anyting im there
if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
int i= ff_find_unused_picture(s, 0);
s->current_picture_ptr= &s->picture[i];
}
if (s->width != avctx->coded_width || s->height != avctx->coded_height){
- ParseContext pc= s->parse_context; //FIXME move these demuxng hack to avformat
+ ParseContext pc= s->parse_context; //FIXME move this demuxing hack to libavformat
s->parse_context.buffer=0;
MPV_common_end(s);
s->parse_context= pc;
if(pos<0) pos=0; // padding is not really read so this might be -1
return pos;
}else{
- if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
+ if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)
if(pos+10>buf_size) pos=buf_size; // oops ;)
return pos;
return -1;
}
- //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
+ /* We need to set current_picture_ptr before reading the header,
+ * otherwise we cannot store anyting in there */
if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
int i= ff_find_unused_picture(s, 0);
s->current_picture_ptr= &s->picture[i];
ff_er_frame_start(s);
//the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type
- //which isnt available before MPV_frame_start()
+ //which is not available before MPV_frame_start()
if (s->msmpeg4_version==5){
if(!ENABLE_WMV2_DECODER || ff_wmv2_decode_secondary_picture_header(s) < 0)
return -1;
return chroma_qp[av_clip(qscale + chroma_qp_index_offset, 0, 51)];
}
-//FIXME need to check that this doesnt overflow signed 32 bit for low qp, i am not sure, it's very close
+//FIXME need to check that this does not overflow signed 32 bit for low qp, i am not sure, it's very close
//FIXME check that gcc inlines this (and optimizes intra & separate_dc stuff away)
static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int separate_dc){
int i;
if(IS_INTRA_PCM(mb_type)){
unsigned int x, y;
- // we assume these blocks are very rare so we dont optimize it
+ // We assume these blocks are very rare so we do not optimize it.
align_get_bits(&s->gb);
// The pixels are stored in the same order as levels in h->mb array.
const uint8_t *ptr;
unsigned int x, y;
- // We assume these blocks are very rare so we dont optimize it.
+ // We assume these blocks are very rare so we do not optimize it.
// FIXME The two following lines get the bitstream position in the cabac
// decode, I think it should be done by a function in cabac.h (or cabac.c).
ptr= h->cabac.bytestream;
buf_index += consumed;
- if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME dont discard SEI id
+ if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME do not discard SEI id
||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
continue;
return pos;
}else{
- if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
+ if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)
if(pos+10>buf_size) pos=buf_size; // oops ;)
return pos;
START_TIMER
j= get_ue_golomb(&gb);
if(j != i){
- printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
+ printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
// return -1;
}
STOP_TIMER("get_ue_golomb");
START_TIMER
j= get_se_golomb(&gb);
if(j != i - COUNT/2){
- printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
+ printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
// return -1;
}
STOP_TIMER("get_se_golomb");
}
if(memcmp(bitstream, out, COUNT)){
- printf("missmatch\n");
+ printf("mismatch\n");
return -1;
}
}
#include "mpegvideo.h"
#define interlaced_dct interlaced_dct_is_a_bad_name
-#define mb_intra mb_intra_isnt_initalized_see_mb_type
+#define mb_intra mb_intra_is_not_initalized_see_mb_type
#define LUMA_DC_BLOCK_INDEX 25
#define CHROMA_DC_BLOCK_INDEX 26
"add $16, %2 \n\t"
"subl $4, %0 \n\t"
"jnz 1b \n\t"
-#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
#else
:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
"add $32, %2 \n\t"
"subl $4, %0 \n\t"
"jnz 1b \n\t"
-#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
#else
:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
"add $32, %2 \n\t"
"subl $4, %0 \n\t"
"jnz 1b \n\t"
-#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
#else
:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
"add $16, %2 \n\t"
"subl $4, %0 \n\t"
"jnz 1b \n\t"
-#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
#else
:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
"add $32, %2 \n\t"
"subl $4, %0 \n\t"
"jnz 1b \n\t"
-#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
#else
:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
"add $32, %2 \n\t"
"subl $2, %0 \n\t"
"jnz 1b \n\t"
-#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
#else
:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
"add $32, %2 \n\t"
"subl $2, %0 \n\t"
"jnz 1b \n\t"
-#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
#else
:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
"add $32, %2 \n\t"
"subl $2, %0 \n\t"
"jnz 1b \n\t"
-#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
#else
:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
:"%"REG_a, "memory");
}
-// Note this is not correctly rounded, but this function is only used for b frames so it doesnt matter
+/* Note this is not correctly rounded, but this function is only
+ * used for B-frames so it does not matter. */
static void DEF(avg_pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
{
MOVQ_BONE(mm6);
"add %5, %3 \n\t"
"subl $4, %0 \n\t"
"jnz 1b \n\t"
-#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
#else
:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
"add $32, %2 \n\t"
"subl $2, %0 \n\t"
"jnz 1b \n\t"
-#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
#else
:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
static av_always_inline void fdct_row_mmx(const int16_t *in, int16_t *out, const int16_t *table)
{
-//FIXME reorder (i dont have a old mmx only cpu here to benchmark ...)
+//FIXME reorder (I do not have an old MMX-only CPU here to benchmark ...)
movd_m2r(*(in + 6), mm1);
punpcklwd_m2r(*(in + 4), mm1);
movq_r2r(mm1, mm2);
: "%"REG_a, "memory"
);
block[0]= block0;
- //Note, we dont do mismatch control for intra as errors cannot accumulate
+ //Note, we do not do mismatch control for intra as errors cannot accumulate
}
static void dct_unquantize_mpeg2_inter_mmx(MpegEncContext *s,
assert((7&(int)(&temp_block[0])) == 0); //did gcc align it correctly?
//s->fdct (block);
- RENAMEl(ff_fdct) (block); //cant be anything else ...
+ RENAMEl(ff_fdct) (block); //cannot be anything else ...
if(s->dct_error_sum)
s->denoise_dct(s, block);
return 0;
}
-AVCodec jpegls_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
+AVCodec jpegls_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them
"jpegls",
CODEC_TYPE_VIDEO,
CODEC_ID_JPEGLS,
s->buffer_index -= len;
memmove(s->buffer, s->buffer+len, s->buffer_index);
- //FIXME fix the audio codec API, so we dont need the memcpy()
+ //FIXME fix the audio codec API, so we do not need the memcpy()
/*for(i=0; i<len; i++){
av_log(avctx, AV_LOG_DEBUG, "%2X ", frame[i]);
}*/
}
-AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
+AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them
"ljpeg",
CODEC_TYPE_VIDEO,
CODEC_ID_LJPEG,
c->uvstride= 8*s->mb_width + 16;
}
- // 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
+ /* 8x8 fullpel search would need a 4x4 chroma compare, which we do
+ * not have yet, and even if we had, the motion estimation code
+ * does not expect it. */
if(s->codec_id != CODEC_ID_SNOW){
if((c->avctx->me_cmp&FF_CMP_CHROMA)/* && !s->dsp.me_cmp[2]*/){
s->dsp.me_cmp[2]= zero_cmp;
type |= CANDIDATE_MB_TYPE_BIDIR_I;
}
//FIXME something smarter
- if(dmin>256*256*16) type&= ~CANDIDATE_MB_TYPE_DIRECT; //dont try direct mode if its invalid for this MB
+ if(dmin>256*256*16) type&= ~CANDIDATE_MB_TYPE_DIRECT; //do not try direct mode if it is invalid for this MB
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])
type |= CANDIDATE_MB_TYPE_DIRECT0;
#if 0
break;
}
if(bitrate_index == 30){
- av_log(avctx, AV_LOG_ERROR, "couldnt find bitrate_index\n");
+ av_log(avctx, AV_LOG_ERROR, "Could not find bitrate_index.\n");
return -1;
}
/* store the vlc & sign at once */
put_bits(&s->pb, table_vlc[code][1]+1, (table_vlc[code][0]<<1) + sign);
} else {
- /* escape seems to be pretty rare <5% so i dont optimize it */
+ /* escape seems to be pretty rare <5% so I do not optimize it */
put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]);
/* escape: only clip in this case */
put_bits(&s->pb, 6, run);
int mb_y= start_code - SLICE_MIN_START_CODE;
if(s2->last_picture_ptr==NULL){
- /* skip b frames if we dont have reference frames */
+ /* Skip B-frames if we do not have reference frames. */
if(s2->pict_type==B_TYPE) break;
- /* skip P frames if we dont have reference frame no valid header */
+ /* Skip P-frames if we do not have reference frame no valid header. */
// if(s2->pict_type==P_TYPE && s2->first_field && !s2->first_slice) break;
}
- /* skip b frames if we are in a hurry */
+ /* Skip B-frames if we are in a hurry. */
if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
if( (avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type==B_TYPE)
||(avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type!=I_TYPE)
|| avctx->skip_frame >= AVDISCARD_ALL)
break;
- /* skip everything if we are in a hurry>=5 */
+ /* Skip everything if we are in a hurry>=5. */
if(avctx->hurry_up>=5) break;
if (!s->mpeg_enc_ctx_allocated) break;
sf[1] = sf[2] = sf[0];
break;
default:
- assert(0); //cant happen
+ assert(0); //cannot happen
code = 0; /* kill warning */
}
* The pixels are allocated/set by calling get_buffer() if shared=0
*/
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
- const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
+ const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
const int mb_array_size= s->mb_stride*s->mb_height;
const int b8_array_size= s->b8_stride*s->mb_height*2;
const int b4_array_size= s->b4_stride*s->mb_height*4;
CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
- //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
+ //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
s->rd_scratchpad= s->me.scratchpad;
s->b_scratchpad= s->me.scratchpad;
s->error_resilience= avctx->error_resilience;
/* set dequantizer, we can't do it during init as it might change for mpeg4
- and we can't do it in the header decode as init isnt called for mpeg4 there yet */
+ and we can't do it in the header decode as init is not called for mpeg4 there yet */
if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
#define IS_ACPRED(a) ((a)&MB_TYPE_ACPRED)
#define IS_QUANT(a) ((a)&MB_TYPE_QUANT)
#define IS_DIR(a, part, list) ((a) & (MB_TYPE_P0L0<<((part)+2*(list))))
-#define USES_LIST(a, list) ((a) & ((MB_TYPE_P0L0|MB_TYPE_P1L0)<<(2*(list)))) ///< does this mb use listX, note doesnt work if subMBs
+#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
#define HAS_CBP(a) ((a)&MB_TYPE_CBP)
int field_poc[2]; ///< h264 top/bottom POC
typedef struct MotionEstContext{
AVCodecContext *avctx;
int skip; ///< set if ME is skipped for the current MB
- int co_located_mv[4][2]; ///< mv from last p frame for direct mode ME
+ int co_located_mv[4][2]; ///< mv from last P-frame for direct mode ME
int direct_basis_mv[4][2];
- uint8_t *scratchpad; ///< data area for the me algo, so that the ME doesnt need to malloc/free
+ uint8_t *scratchpad; ///< data area for the ME algo, so that the ME does not need to malloc/free
uint8_t *best_mb;
uint8_t *temp_mb[2];
uint8_t *temp;
/* sequence parameters */
int context_initialized;
- int input_picture_number; ///< used to set pic->display_picture_number, shouldnt be used for/by anything else
- int coded_picture_number; ///< used to set pic->coded_picture_number, shouldnt be used for/by anything else
+ int input_picture_number; ///< used to set pic->display_picture_number, should not be used for/by anything else
+ int coded_picture_number; ///< used to set pic->coded_picture_number, should not be used for/by anything else
int picture_number; //FIXME remove, unclear definition
int picture_in_gop_number; ///< 0-> first pic in gop, ...
int b_frames_since_non_b; ///< used for encoding, relative to not yet reordered input
/* luminance h263 */
uni_code= DCtab_lum[size][0];
uni_len = DCtab_lum[size][1];
- uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
+ uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
if (size > 0) {
uni_code<<=size; uni_code|=l;
/* chrominance h263 */
uni_code= DCtab_chrom[size][0];
uni_len = DCtab_chrom[size][1];
- uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
+ uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
if (size > 0) {
uni_code<<=size; uni_code|=l;
break;
}
- s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
+ s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
return 0;
}
/**
* free what has been allocated by avcodec_thread_init().
- * must be called after decoding has finished, especially dont call while avcodec_thread_execute() is running
+ * must be called after decoding has finished, especially do not call while avcodec_thread_execute() is running
*/
void avcodec_thread_free(AVCodecContext *s){
ThreadContext *c= s->thread_opaque;
next= strchr(p, ';');
if(next){
- (*next)=0; //sscanf in unbelieavle slow on looong strings //FIXME copy / dont write
+ (*next)=0; //sscanf in unbelievably slow on looong strings //FIXME copy / do not write
next++;
}
e= sscanf(p, " in:%d ", &picture_number);
else if(q < last_q - maxdiff) q= last_q - maxdiff;
}
- rcc->last_qscale_for[pict_type]= q; //Note we cant do that after blurring
+ rcc->last_qscale_for[pict_type]= q; //Note we cannot do that after blurring
if(pict_type!=B_TYPE)
rcc->last_non_b_pict_type= pict_type;
bits_tab[i]= bits;
}
- /* handle qmin/qmax cliping */
+ /* handle qmin/qmax clipping */
if(s->flags&CODEC_FLAG_NORMALIZE_AQP){
float factor= bits_sum/cplx_sum;
for(i=0; i<s->mb_num; i++){
my= ref_my;
}
}
- //FIXME if mb_cmp != SSE then intra cant be compared currently and mb_penalty vs. lambda2
+ //FIXME if mb_cmp != SSE then intra cannot be compared currently and mb_penalty vs. lambda2
// subpel search
base_bits= get_rac_count(&s->c) - 8*(s->c.bytestream - s->c.bytestream_start);
}
*b= backup;
- return av_clip(((ab<<LOG2_OBMC_MAX) + aa/2)/aa, 0, 255); //FIXME we shouldnt need cliping
+ return av_clip(((ab<<LOG2_OBMC_MAX) + aa/2)/aa, 0, 255); //FIXME we should not need clipping
}
static inline int get_block_bits(SnowContext *s, int x, int y, int w){
for(i=0; i<3; i++)
color[i]= get_dc(s, mb_x, mb_y, i);
- // get previous score (cant be cached due to OBMC)
+ // get previous score (cannot be cached due to OBMC)
if(pass > 0 && (block->type&BLOCK_INTRA)){
int color0[3]= {block->color[0], block->color[1], block->color[2]};
check_block(s, mb_x, mb_y, color0, 1, *obmc_edged, &best_rd);
int mvx= pmv[i]->x + (i&1)*16;
int mvy= pmv[i]->y + (i>>1)*16;
- ///XXX /FIXME cliping or padding?
+ ///XXX /FIXME clipping or padding?
if(y + (mvy >> 1)<0)
mvy= 0;
if(x + (mvx >> 1)<0)
s->current_picture.pict_type = s->pict_type;
s->current_picture.key_frame = (s->pict_type == I_TYPE);
- /* skip b frames if we dont have reference frames */
+ /* Skip B-frames if we do not have reference frames. */
if (s->last_picture_ptr == NULL && s->pict_type == B_TYPE) return 0;
- /* skip b frames if we are in a hurry */
+ /* Skip B-frames if we are in a hurry. */
if (avctx->hurry_up && s->pict_type == B_TYPE) return 0;
- /* skip everything if we are in a hurry >= 5 */
+ /* Skip everything if we are in a hurry >= 5. */
if (avctx->hurry_up >= 5) return 0;
if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
avctx->frame_number = s->picture_number - 1;
- /* dont output the last pic after seeking */
+ /* Do not output the last pic after seeking. */
if (s->last_picture_ptr || s->low_delay) {
*data_size = sizeof(AVFrame);
}
pixel_size= picture.linesize[0]*8 / w;
//av_log(NULL, AV_LOG_ERROR, "%d %d %d %d\n", (int)picture.data[1], w, h, s->pix_fmt);
assert(pixel_size>=1);
- //FIXME next ensures that linesize= 2^x uvlinesize, thats needed because some MC code assumes it
+ //FIXME next ensures that linesize= 2^x uvlinesize, that is needed because some MC code assumes it
if(pixel_size == 3*8)
w= ALIGN(w, STRIDE_ALIGN<<h_chroma_shift);
else
}
#define OFFSET(x) offsetof(AVCodecContext,x)
-#define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
+#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
//these names are too long to be readable
#define V AV_OPT_FLAG_VIDEO_PARAM
#define A AV_OPT_FLAG_AUDIO_PARAM
static AbvEntry frame_abvs[] = {
{ "ntsc", 720, 480, 30000, 1001 },
{ "pal", 720, 576, 25, 1 },
- { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
- { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
+ { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant NTSC */
+ { "qpal", 352, 288, 25, 1 }, /* VCD compliant PAL */
{ "sntsc", 640, 480, 30000, 1001 }, /* square pixel NTSC */
{ "spal", 768, 576, 25, 1 }, /* square pixel PAL */
{ "film", 352, 240, 24, 1 },
return 0;
}
- //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
+ /* We need to set current_picture_ptr before reading the header,
+ * otherwise we cannot store anyting in there. */
if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
int i= ff_find_unused_picture(s, 0);
s->current_picture_ptr= &s->picture[i];
int maxval = 1;
if (c->books[l] != -1)
maxval = venc->codebooks[c->books[l]].nentries;
- // coded could be -1, but this still works, cause thats 0
+ // coded could be -1, but this still works, cause that is 0
if (coded[counter + k] < maxval) break;
}
assert(l != csub);
}
/**
- * free what has been allocated by avcodec_thread_init().
- * must be called after decoding has finished, especially dont call while avcodec_thread_execute() is running
+ * Free what has been allocated by avcodec_thread_init().
+ * Must be called after decoding has finished, especially do not call while avcodec_thread_execute() is running.
*/
void avcodec_thread_free(AVCodecContext *s){
ThreadContext *c= s->thread_opaque;
return 0;
}
-// nearly idential to wmv1 but thats just because we dont use the useless M$ crap features
-// its duplicated here in case someone wants to add support for these carp features
+/* Nearly identical to wmv1 but that is just because we do not use the
+ * useless M$ crap features. It is duplicated here in case someone wants
+ * to add support for these crap features. */
void ff_wmv2_encode_mb(MpegEncContext * s,
DCTELEM block[6][64],
int motion_x, int motion_y)
get_str16_nolen(pb, name_len, name, sizeof(name));
//av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d <%s>\n", i, stream_num, name_len, value_type, value_len, name);
- value_num= get_le16(pb);//we should use get_value() here but it doesnt work 2 is le16 here but le32 elsewhere
+ value_num= get_le16(pb);//we should use get_value() here but it does not work 2 is le16 here but le32 elsewhere
url_fskip(pb, value_len - 2);
if(stream_num<128){
#define AVFMT_RAWPICTURE 0x0020 /**< format wants AVPicture structure for
raw picture data */
#define AVFMT_GLOBALHEADER 0x0040 /**< format wants global header */
-#define AVFMT_NOTIMESTAMPS 0x0080 /**< format doesnt need / has any timestamps */
+#define AVFMT_NOTIMESTAMPS 0x0080 /**< format does not need / have any timestamps */
#define AVFMT_GENERIC_INDEX 0x0100 /**< use generic index building code */
typedef struct AVOutputFormat {
int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */
/* ffmpeg.c private use */
int stream_copy; /**< if set, just copy stream */
- enum AVDiscard discard; ///< selects which packets can be discarded at will and dont need to be demuxed
+ enum AVDiscard discard; ///< selects which packets can be discarded at will and do not need to be demuxed
//FIXME move stuff to a flags field?
/** quality, as it has been removed from AVCodecContext and put in AVVideoFrame
- * MN:dunno if thats the right place, for it */
+ * MN: dunno if that is the right place for it */
float quality;
/** decoding: pts of the first frame of the stream, in stream time base. */
int64_t start_time;
*
* @param ic media file handle
* @return >=0 if OK. AVERROR_xxx if error.
- * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
+ * @todo Let user decide somehow what information is needed so we do not waste time geting stuff the user does not need.
*/
int av_find_stream_info(AVFormatContext *ic);
/**
* Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
- * this isnt supposed to be called directly by a user application, but by demuxers
+ * This is not supposed to be called directly by a user application, but by demuxers.
* @param target_ts target timestamp in the time base of the given stream
* @param stream_index stream number
*/
* Updates cur_dts of all streams based on given timestamp and AVStream.
*
* Stream ref_st unchanged, others set cur_dts in their native timebase
- * only needed for timestamp wrapping or if (dts not set and pts!=dts)
+ * only needed for timestamp wrapping or if (dts not set and pts!=dts).
* @param timestamp new dts expressed in time_base of param ref_st
* @param ref_st reference stream giving time_base of param timestamp
*/
/**
* Does a binary search using read_timestamp().
- * this isnt supposed to be called directly by a user application, but by demuxers
+ * This is not supposed to be called directly by a user application, but by demuxers.
* @param target_ts target timestamp in the time base of the given stream
* @param stream_index stream number
*/
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap);
/**
- * allocate the stream private data and write the stream header to an
- * output media file
+ * Allocate the stream private data and write the stream header to an
+ * output media file.
*
* @param s media file handle
* @return 0 if OK. AVERROR_xxx if error.
flags |= FLV_SAMPLERATE_SPECIAL;
break;
default:
- av_log(enc, AV_LOG_ERROR, "flv doesnt support that sample rate, choose from (44100, 22050, 11025)\n");
+ av_log(enc, AV_LOG_ERROR, "flv does not support that sample rate, choose from (44100, 22050, 11025).\n");
return -1;
}
break;
}
- //Read QT version 1 fields. In version 0 theese dont exist
+ //Read QT version 1 fields. In version 0 these do not exist.
dprintf(c->fc, "version =%d, isom =%d\n",version,c->isom);
if(!c->isom) {
if(version==1) {
}
for(i=0; i<mov->total_streams; i++) {
- /* dont need those anymore */
+ /* Do not need those anymore. */
av_freep(&mov->streams[i]->chunk_offsets);
av_freep(&mov->streams[i]->sample_to_chunk);
av_freep(&mov->streams[i]->sample_sizes);
/* iTunes meta data */
mov_write_meta_tag(pb, mov, s);
- if(mov->mode == MODE_MOV){ // the title field breaks gtkpod with mp4 and my suspicion is that stuff isnt valid in mp4
+ if(mov->mode == MODE_MOV){ // the title field breaks gtkpod with mp4 and my suspicion is that stuff is not valid in mp4
/* Requirements */
for (i=0; i<mov->nb_streams; i++) {
if(mov->tracks[i].entry <= 0) continue;
stuffing_size = payload_size - av_fifo_size(&stream->fifo);
- // first byte doesnt fit -> reset pts/dts + stuffing
+ // first byte does not fit -> reset pts/dts + stuffing
if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
int timestamp_len=0;
if(dts != pts)
struct NSVf_header {
uint32_t chunk_tag; /* 'NSVf' */
uint32_t chunk_size;
- uint32_t file_size; /* max 4GB ??? noone learns anything it seems :^) */
+ uint32_t file_size; /* max 4GB ??? no one learns anything it seems :^) */
uint32_t file_length; //unknown1; /* what about MSB of file_size ? */
uint32_t info_strings_size; /* size of the info strings */ //unknown2;
uint32_t table_entries;
{ CODEC_ID_VP4, MKTAG('V', 'P', '4', ' ') },
{ CODEC_ID_VP4, MKTAG('V', 'P', '4', '0') },
*/
- { CODEC_ID_XVID, MKTAG('X', 'V', 'I', 'D') }, /* cf sample xvid decoder from nsv_codec_sdk.zip */
+ { CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') }, /* cf sample xvid decoder from nsv_codec_sdk.zip */
{ CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', '3') },
{ 0, 0 },
};
int64_t packet_start[3]; //0-> startcode less, 1-> short startcode 2-> long startcodes
FrameCode frame_code[256];
unsigned int stream_count;
- uint64_t next_startcode; ///< stores the next startcode if it has alraedy been parsed but the stream isnt seekable
+ uint64_t next_startcode; ///< stores the next startcode if it has already been parsed but the stream is not seekable
StreamContext *stream;
int max_distance;
int max_short_distance;
uint64_t state=0;
if(pos >= 0)
- 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
+ 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
while(!url_feof(bc)){
state= (state<<8) | get_byte(bc);
uint16_t size_lsb;
int16_t pts_delta;
uint8_t reserved_count;
-} FrameCode; // maybe s/FrameCode/framecode_t/ or change all to java style but dont mix
+} FrameCode; // maybe s/FrameCode/framecode_t/ or change all to Java style but do not mix
typedef struct {
int last_flags;
// int written_packet_size;
// int64_t packet_start[3]; //0-> startcode less, 1-> short startcode 2-> long startcodes
FrameCode frame_code[256];
- uint64_t next_startcode; ///< stores the next startcode if it has alraedy been parsed but the stream isnt seekable
+ uint64_t next_startcode; ///< stores the next startcode if it has already been parsed but the stream is not seekable
StreamContext *stream;
unsigned int max_distance;
unsigned int time_base_count;
uint64_t state=0;
if(pos >= 0)
- 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
+ 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
while(!url_feof(bc)){
state= (state<<8) | get_byte(bc);
next_node[0]->back_ptr, next_node[1]->back_ptr, flags, &ts, nut_read_timestamp);
if(pos2>=0)
pos= pos2;
- //FIXME dir but i think it doesnt matter
+ //FIXME dir but i think it does not matter
}
dummy.pos= pos;
sp= av_tree_find(nut->syncpoints, &dummy, sp_pos_cmp, NULL);
st->need_parsing = AVSTREAM_PARSE_FULL;
/* for mjpeg, specify frame rate */
- /* for mpeg4 specify it too (most mpeg4 streams dont have the fixed_vop_rate set ...)*/
+ /* for mpeg4 specify it too (most mpeg4 streams do not have the fixed_vop_rate set ...)*/
if (ap->time_base.num) {
av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
} else if ( st->codec->codec_id == CODEC_ID_MJPEG ||
}
if (enc->codec_id == CODEC_ID_MP2 || enc->codec_id == CODEC_ID_MP3 || enc->codec_id == CODEC_ID_GSM_MS) {
- blkalign = enc->frame_size; //this is wrong, but seems many demuxers dont work if this is set correctly
+ blkalign = enc->frame_size; //this is wrong, but it seems many demuxers do not work if this is set correctly
//blkalign = 144 * enc->bit_rate/enc->sample_rate;
} else if (enc->codec_id == CODEC_ID_ADPCM_G726) { //
blkalign = 1;
infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
/* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
- In my test, the faad decoder doesnt behave correctly when sending each AU one by one
+ In my test, the FAAD decoder does not behave correctly when sending each AU one by one
but does when sending the whole as one big packet... */
infos->au_headers[0].size = 0;
infos->au_headers[0].index = 0;
break;
default:
/* not supported */
- av_log(s, AV_LOG_ERROR, "swf doesnt support that sample rate, choose from (44100, 22050, 11025)\n");
+ av_log(s, AV_LOG_ERROR, "swf does not support that sample rate, choose from (44100, 22050, 11025).\n");
return -1;
}
v |= 0x02; /* 16 bit playback */
}
#define OFFSET(x) offsetof(AVFormatContext,x)
-#define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
+#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
//these names are too long to be readable
#define E AV_OPT_FLAG_ENCODING_PARAM
#define D AV_OPT_FLAG_DECODING_PARAM
if (delay &&
pc && pc->pict_type != FF_B_TYPE)
presentation_delayed = 1;
- /* this may be redundant, but it shouldnt hurt */
+ /* This may be redundant, but it should not hurt. */
if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
presentation_delayed = 1;
return -1;
memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
st->nb_index_entries++;
- }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
+ }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
distance= ie->min_distance;
}
MedianDeinterlace# E Ec Ec
TempDeNoiser# E e e Ec
-* i dont have a 3dnow CPU -> its untested, but noone said it doesnt work so it seems to work
-# more or less selfinvented filters so the exactness isnt too meaningfull
+* i do not have a 3DNow! CPU -> it is untested, but no one said it does not work so it seems to work
+# more or less selfinvented filters so the exactness is not too meaningful
E = Exact implementation
e = allmost exact implementation (slightly different rounding,...)
a = alternative / approximate impl
* Experimental Filter 1 (Horizontal)
* will not damage linear gradients
* Flat blocks should look like they where passed through the (1,1,2,2,4,2,2,1,1) 9-Tap filter
- * can only smooth blocks at the expected locations (it cant smooth them if they did move)
- * MMX2 version does correct clipping C version doesnt
+ * can only smooth blocks at the expected locations (it cannot smooth them if they did move)
+ * MMX2 version does correct clipping C version does not
* not identical with the vertical one
*/
static inline void horizX1Filter(uint8_t *src, int stride, int QP)
#include "postprocess_template.c"
#endif
-// minor note: the HAVE_xyz is messed up after that line so dont use it
+// minor note: the HAVE_xyz is messed up after that line so do not use it.
static inline void postProcess(uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
QP_STORE_T QPs[], int QPStride, int isColor, pp_mode_t *vm, pp_context_t *vc)
PPMode *ppMode= (PPMode *)vm;
c->ppMode= *ppMode; //FIXME
- // useing ifs here as they are faster than function pointers allthough the
- // difference wouldnt be messureable here but its much better because
- // someone might exchange the cpu whithout restarting mplayer ;)
+ // Using ifs here as they are faster than function pointers although the
+ // difference would not be measureable here but it is much better because
+ // someone might exchange the CPU whithout restarting MPlayer ;)
#ifdef RUNTIME_CPUDETECT
#if defined(ARCH_X86)
// ordered per speed fasterst first
for(i=0; i<3; i++)
{
- //Note:the +17*1024 is just there so i dont have to worry about r/w over te end
+ //Note: The +17*1024 is just there so i do not have to worry about r/w over the end.
reallocAlign((void **)&c->tempBlured[i], 8, stride*mbHeight*16 + 17*1024);
reallocAlign((void **)&c->tempBluredPast[i], 8, 256*((height+7)&(~7))/2 + 17*1024);//FIXME size
}
# define PIC
#endif
-//use if u want a faster postprocessing code
-//cant differentiate between chroma & luma filters (both on or both off)
-//obviosly the -pp option at the commandline has no effect except turning the here selected
+//use if you want a faster postprocessing code
+//cannot differentiate between chroma & luma filters (both on or both off)
+//obviously the -pp option on the command line has no effect except turning the here selected
//filters on
//#define COMPILE_TIME_MODE 0x77
"paddb " #a ", " #b " \n\t"
#endif
-//FIXME? |255-0| = 1 (shouldnt be a problem ...)
+//FIXME? |255-0| = 1 (should not be a problem ...)
#ifdef HAVE_MMX
/**
* Check if the middle 8x8 Block in the given 8x16 block is flat
* Experimental Filter 1
* will not damage linear gradients
* Flat blocks should look like they where passed through the (1,1,2,2,4,2,2,1,1) 9-Tap filter
- * can only smooth blocks at the expected locations (it cant smooth them if they did move)
- * MMX2 version does correct clipping C version doesnt
+ * can only smooth blocks at the expected locations (it cannot smooth them if they did move)
+ * MMX2 version does correct clipping C version does not
*/
static inline void RENAME(vertX1Filter)(uint8_t *src, int stride, PPContext *co)
{
QP_STORE_T QPs[], int QPStride, int isColor, PPContext *c);
/**
- * Copies a block from src to dst and fixes the blacklevel
- * levelFix == 0 -> dont touch the brighness & contrast
+ * Copies a block from src to dst and fixes the blacklevel.
+ * levelFix == 0 -> do not touch the brighness & contrast
*/
#undef SCALED_CPY
c->max_b_frames = 2;
}
if (c->codec_id == CODEC_ID_MPEG1VIDEO){
- /* needed to avoid using macroblocks in which some coeffs overflow
- this doesnt happen with normal video, it just happens here as the
- motion of the chroma plane doesnt match the luma plane */
+ /* Needed to avoid using macroblocks in which some coeffs overflow.
+ This does not happen with normal video, it just happens here as
+ the motion of the chroma plane does not match the luma plane. */
c->mb_decision=2;
}
// some formats want stream headers to be separate
AVPacket pkt;
int64_t pktnum = 0;
int64_t maxpkts = 0;
- int dontquit = 0;
+ int donotquit = 0;
int nowrite = 0;
int err;
if ((argc > 1) && !strncmp(argv[1], "-", 1)) {
if (strchr(argv[1], 'w'))
- dontquit = 1;
+ donotquit = 1;
if (strchr(argv[1], 'n'))
nowrite = 1;
argv++;
break;
}
- while (dontquit)
+ while (donotquit)
sleep(60);
return 0;
ret = av_open_input_file(&ic, filename, NULL, 0, NULL);
if (ret < 0) {
- fprintf(stderr, "cant open %s\n", filename);
+ fprintf(stderr, "cannot open %s\n", filename);
exit(1);
}
projects / platform / upstream / libav.git / commitdiff