diff --git a/cmdutils.h b/cmdutils.h
index 61d07887b0e25c32fd72188cc0662b74a7b09cd1..35bef38002997a9f391a0123405545b15c6ebded 100644
--- a/cmdutils.h
+++ b/cmdutils.h
@@ -105,7 +105,8 @@ int opt_timelimit(const char *opt, const char *arg);
* @param min the minimum valid accepted value
* @param max the maximum valid accepted value
*/
-double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max);
+double parse_number_or_die(const char *context, const char *numstr, int type,
+ double min, double max);
/**
* Parse a string specifying a time and return its corresponding
@@ -121,7 +122,8 @@ double parse_number_or_die(const char *context, const char *numstr, int type, do
*
* @see parse_date()
*/
-int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration);
+int64_t parse_time_or_die(const char *context, const char *timestr,
+ int is_duration);
typedef struct SpecifierOpt {
char *specifier; /**< stream/chapter/program/... specifier */
@@ -167,7 +169,8 @@ typedef struct {
const char *argname;
} OptionDef;
-void show_help_options(const OptionDef *options, const char *msg, int mask, int value);
+void show_help_options(const OptionDef *options, const char *msg, int mask,
+ int value);
/**
* Show help for all options with given flags in class and all its
@@ -193,7 +196,8 @@ void parse_options(void *optctx, int argc, char **argv, const OptionDef *options
*
* @return on success 1 if arg was consumed, 0 otherwise; negative number on error
*/
-int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options);
+int parse_option(void *optctx, const char *opt, const char *arg,
+ const OptionDef *options);
/**
* Find the '-loglevel' option in the command line args and apply it.
@@ -221,7 +225,8 @@ int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec);
* @param st A stream from s for which the options should be filtered.
* @return a pointer to the created dictionary
*/
-AVDictionary *filter_codec_opts(AVDictionary *opts, AVCodec *codec, AVFormatContext *s, AVStream *st);
+AVDictionary *filter_codec_opts(AVDictionary *opts, AVCodec *codec,
+ AVFormatContext *s, AVStream *st);
/**
* Setup AVCodecContext options for avformat_find_stream_info().
@@ -234,7 +239,8 @@ AVDictionary *filter_codec_opts(AVDictionary *opts, AVCodec *codec, AVFormatCont
* @return pointer to the created array of dictionaries, NULL if it
* cannot be created
*/
-AVDictionary **setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts);
+AVDictionary **setup_find_stream_info_opts(AVFormatContext *s,
+ AVDictionary *codec_opts);
/**
* Print an error message to stderr, indicating filename and a human
diff --git a/doc/RELEASE_NOTES b/doc/RELEASE_NOTES
index 24edc2e3b244852d4a9d621698fff9b74a068eb3..ad4279cc829a6c6ecb891f557f788a128ab5dfa5 100644
--- a/doc/RELEASE_NOTES
+++ b/doc/RELEASE_NOTES
@@ -6,7 +6,6 @@ Release Notes
General notes
-------------
-
This release is binary compatible with 0.8. The 'ffmpeg' command-line tool has
been extended to also support the command line syntax and features of a tool
called avconv.
@@ -32,7 +31,30 @@ API changes
A number of additional APIs have been introduced and some existing
functions have been deprecated and are scheduled for removal in the next
-release. Please see the file doc/APIchanges for details along with
+release. Significant API changes include:
+
+* new audio decoding API which decodes from an AVPacket to an AVFrame and
+is able to use AVCodecContext.get_buffer() in the similar way as video decoding.
+
+* new audio encoding API which encodes from an AVFrame to an AVPacket, thus
+allowing it to properly output timing information and side data.
+
+* rewritten AVOptions API with better built-in support for private options.
+
+* private options support for demuxers [avformat_open_input()], muxers
+[avformat_write_header()], encoders and decoders [avcodec_open2()].
+As a result, many format- or codec-specific fields and flags in AVFormatContext
+and AVCodecContext were deprecated -- notably most of CODEC_FLAG2_* and many
+CODEC_FLAG_*.
+
+* new API for custom IO interrupt callbacks.
+
+* #include cleanup in libavutil -- libavutil/avutil.h no longer includes all
+the other headers in libavutil, they must be included manually. One specific
+result is that libavutil/mathematics.h is no longer included from
+libavcodec/avcodec.h, which is a common source of errors.
+
+Please see the file doc/APIchanges for details along with
similar programmer-centric information.
@@ -40,5 +62,13 @@ similar programmer-centric information.
Other notable changes
---------------------
+Libavcodec and libavformat built as shared libraries now hide non-public
+symbols. This will break applications using those symbols. Possible solutions
+are, in order of preference:
+1) Try finding a way of accomplishing the same with public API.
+2) If there is no corresponding public API, but you think there should be,
+post a request on the user mailing list or IRC channel.
+3) Finally if your program needs access to FFmpeg / libavcodec / libavformat
+internals for some special reason then the best solution is to link statically.
Please see the Changelog file for a more detailed list of changes.
diff --git a/ffprobe.c b/ffprobe.c
index a5559a4429bd73f0211daccdf9d2bbacc07eb5a6..169b99590fcca8f4a37761a87cea791ee50bbcaf 100644
--- a/ffprobe.c
+++ b/ffprobe.c
@@ -109,13 +109,13 @@ static char *value_string(char *buf, int buf_size, struct unit_value uv)
if (uv.unit == unit_byte_str && use_byte_value_binary_prefix) {
index = (long long int) (log(vald)/log(2)) / 10;
- index = av_clip(index, 0, FF_ARRAY_ELEMS(binary_unit_prefixes) -1);
- vald /= pow(2, index*10);
+ index = av_clip(index, 0, FF_ARRAY_ELEMS(binary_unit_prefixes) - 1);
+ vald /= pow(2, index * 10);
prefix_string = binary_unit_prefixes[index];
} else {
index = (long long int) (log10(vald)) / 3;
- index = av_clip(index, 0, FF_ARRAY_ELEMS(decimal_unit_prefixes) -1);
- vald /= pow(10, index*3);
+ index = av_clip(index, 0, FF_ARRAY_ELEMS(decimal_unit_prefixes) - 1);
+ vald /= pow(10, index * 3);
prefix_string = decimal_unit_prefixes[index];
}
@@ -1557,7 +1557,8 @@ static int open_input_file(AVFormatContext **fmt_ctx_ptr, const char *filename)
AVFormatContext *fmt_ctx = NULL;
AVDictionaryEntry *t;
- if ((err = avformat_open_input(&fmt_ctx, filename, iformat, &format_opts)) < 0) {
+ if ((err = avformat_open_input(&fmt_ctx, filename,
+ iformat, &format_opts)) < 0) {
print_error(filename, err);
return err;
}
@@ -1581,8 +1582,9 @@ static int open_input_file(AVFormatContext **fmt_ctx_ptr, const char *filename)
AVCodec *codec;
if (!(codec = avcodec_find_decoder(stream->codec->codec_id))) {
- av_log(NULL, AV_LOG_ERROR, "Unsupported codec with id %d for input stream %d\n",
- stream->codec->codec_id, stream->index);
+ av_log(NULL, AV_LOG_ERROR,
+ "Unsupported codec with id %d for input stream %d\n",
+ stream->codec->codec_id, stream->index);
} else if (avcodec_open2(stream->codec, codec, NULL) < 0) {
av_log(NULL, AV_LOG_ERROR, "Error while opening codec for input stream %d\n",
stream->index);
@@ -1700,8 +1702,9 @@ static int opt_format(const char *opt, const char *arg)
static void opt_input_file(void *optctx, const char *arg)
{
if (input_filename) {
- av_log(NULL, AV_LOG_ERROR, "Argument '%s' provided as input filename, but '%s' was already specified.\n",
- arg, input_filename);
+ av_log(NULL, AV_LOG_ERROR,
+ "Argument '%s' provided as input filename, but '%s' was already specified.\n",
+ arg, input_filename);
exit(1);
}
if (!strcmp(arg, "-"))
diff --git a/libavcodec/error_resilience.c b/libavcodec/error_resilience.c
index a3075e18da4fc9bba8f7707677a565308b3215d9..8bb5d0c0dec8015fd48930e4aed1189f9b714845 100644
--- a/libavcodec/error_resilience.c
+++ b/libavcodec/error_resilience.c
@@ -40,30 +40,33 @@
*/
#undef mb_intra
-static void decode_mb(MpegEncContext *s, int ref){
- s->dest[0] = s->current_picture.f.data[0] + (s->mb_y * 16 * s->linesize) + s->mb_x * 16;
+static void decode_mb(MpegEncContext *s, int ref)
+{
+ s->dest[0] = s->current_picture.f.data[0] + (s->mb_y * 16 * s->linesize) + s->mb_x * 16;
s->dest[1] = s->current_picture.f.data[1] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
s->dest[2] = s->current_picture.f.data[2] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
- if(CONFIG_H264_DECODER && s->codec_id == CODEC_ID_H264){
- H264Context *h= (void*)s;
- h->mb_xy= s->mb_x + s->mb_y*s->mb_stride;
+ if (CONFIG_H264_DECODER && s->codec_id == CODEC_ID_H264) {
+ H264Context *h = (void*)s;
+ h->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
memset(h->non_zero_count_cache, 0, sizeof(h->non_zero_count_cache));
- assert(ref>=0);
+ assert(ref >= 0);
/* FIXME: It is possible albeit uncommon that slice references
* differ between slices. We take the easy approach and ignore
* it for now. If this turns out to have any relevance in
* practice then correct remapping should be added. */
if (ref >= h->ref_count[0])
- ref=0;
- fill_rectangle(&s->current_picture.f.ref_index[0][4*h->mb_xy], 2, 2, 2, ref, 1);
+ ref = 0;
+ fill_rectangle(&s->current_picture.f.ref_index[0][4 * h->mb_xy],
+ 2, 2, 2, ref, 1);
fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
- fill_rectangle(h->mv_cache[0][ scan8[0] ], 4, 4, 8, pack16to32(s->mv[0][0][0],s->mv[0][0][1]), 4);
+ fill_rectangle(h->mv_cache[0][scan8[0]], 4, 4, 8,
+ pack16to32(s->mv[0][0][0], s->mv[0][0][1]), 4);
assert(!FRAME_MBAFF);
ff_h264_hl_decode_mb(h);
- }else{
- assert(ref==0);
- MPV_decode_mb(s, s->block);
+ } else {
+ assert(ref == 0);
+ MPV_decode_mb(s, s->block);
}
}
@@ -71,82 +74,89 @@ static void decode_mb(MpegEncContext *s, int ref){
* @param stride the number of MVs to get to the next row
* @param mv_step the number of MVs per row or column in a macroblock
*/
-static void set_mv_strides(MpegEncContext *s, int *mv_step, int *stride){
- if(s->codec_id == CODEC_ID_H264){
- H264Context *h= (void*)s;
+static void set_mv_strides(MpegEncContext *s, int *mv_step, int *stride)
+{
+ if (s->codec_id == CODEC_ID_H264) {
+ H264Context *h = (void*)s;
assert(s->quarter_sample);
- *mv_step= 4;
- *stride= h->b_stride;
- }else{
- *mv_step= 2;
- *stride= s->b8_stride;
+ *mv_step = 4;
+ *stride = h->b_stride;
+ } else {
+ *mv_step = 2;
+ *stride = s->b8_stride;
}
}
/**
* Replace the current MB with a flat dc-only version.
*/
-static void put_dc(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int mb_x, int mb_y)
+static void put_dc(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb,
+ uint8_t *dest_cr, int mb_x, int mb_y)
{
int dc, dcu, dcv, y, i;
- for(i=0; i<4; i++){
- dc= s->dc_val[0][mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride];
- if(dc<0) dc=0;
- else if(dc>2040) dc=2040;
- for(y=0; y<8; y++){
+ for (i = 0; i < 4; i++) {
+ dc = s->dc_val[0][mb_x * 2 + (i & 1) + (mb_y * 2 + (i >> 1)) * s->b8_stride];
+ if (dc < 0)
+ dc = 0;
+ else if (dc > 2040)
+ dc = 2040;
+ for (y = 0; y < 8; y++) {
int x;
- for(x=0; x<8; x++){
- dest_y[x + (i&1)*8 + (y + (i>>1)*8)*s->linesize]= dc/8;
- }
+ for (x = 0; x < 8; x++)
+ dest_y[x + (i & 1) * 8 + (y + (i >> 1) * 8) * s->linesize] = dc / 8;
}
}
- dcu = s->dc_val[1][mb_x + mb_y*s->mb_stride];
- dcv = s->dc_val[2][mb_x + mb_y*s->mb_stride];
- if (dcu<0 ) dcu=0;
- else if(dcu>2040) dcu=2040;
- if (dcv<0 ) dcv=0;
- else if(dcv>2040) dcv=2040;
- for(y=0; y<8; y++){
+ dcu = s->dc_val[1][mb_x + mb_y * s->mb_stride];
+ dcv = s->dc_val[2][mb_x + mb_y * s->mb_stride];
+ if (dcu < 0)
+ dcu = 0;
+ else if (dcu > 2040)
+ dcu = 2040;
+ if (dcv < 0)
+ dcv = 0;
+ else if (dcv > 2040)
+ dcv = 2040;
+ for (y = 0; y < 8; y++) {
int x;
- for(x=0; x<8; x++){
+ for (x = 0; x < 8; x++) {
dest_cb[x + y * s->uvlinesize] = dcu / 8;
dest_cr[x + y * s->uvlinesize] = dcv / 8;
}
}
}
-static void filter181(int16_t *data, int width, int height, int stride){
- int x,y;
+static void filter181(int16_t *data, int width, int height, int stride)
+{
+ int x, y;
/* horizontal filter */
- for(y=1; y<height-1; y++){
- int prev_dc= data[0 + y*stride];
+ for (y = 1; y < height - 1; y++) {
+ int prev_dc = data[0 + y * stride];
- for(x=1; x<width-1; x++){
+ for (x = 1; x < width - 1; x++) {
int dc;
-
- dc= - prev_dc
- + data[x + y*stride]*8
- - data[x + 1 + y*stride];
- dc= (dc*10923 + 32768)>>16;
- prev_dc= data[x + y*stride];
- data[x + y*stride]= dc;
+ dc = -prev_dc +
+ data[x + y * stride] * 8 -
+ data[x + 1 + y * stride];
+ dc = (dc * 10923 + 32768) >> 16;
+ prev_dc = data[x + y * stride];
+ data[x + y * stride] = dc;
}
}
/* vertical filter */
- for(x=1; x<width-1; x++){
- int prev_dc= data[x];
+ for (x = 1; x < width - 1; x++) {
+ int prev_dc = data[x];
- for(y=1; y<height-1; y++){
+ for (y = 1; y < height - 1; y++) {
int dc;
- dc= - prev_dc
- + data[x + y *stride]*8
- - data[x + (y+1)*stride];
- dc= (dc*10923 + 32768)>>16;
- prev_dc= data[x + y*stride];
- data[x + y*stride]= dc;
+ dc = -prev_dc +
+ data[x + y * stride] * 8 -
+ data[x + (y + 1) * stride];
+ dc = (dc * 10923 + 32768) >> 16;
+ prev_dc = data[x + y * stride];
+ data[x + y * stride] = dc;
}
}
}
@@ -156,7 +166,9 @@ static void filter181(int16_t *data, int width, int height, int stride){
* @param w width in 8 pixel blocks
* @param h height in 8 pixel blocks
*/
-static void guess_dc(MpegEncContext *s, int16_t *dc, int w, int h, int stride, int is_luma){
+static void guess_dc(MpegEncContext *s, int16_t *dc, int w,
+ int h, int stride, int is_luma)
+{
int b_x, b_y;
int16_t (*col )[4] = av_malloc(stride*h*sizeof( int16_t)*4);
uint16_t (*dist)[4] = av_malloc(stride*h*sizeof(uint16_t)*4);
@@ -218,29 +230,27 @@ static void guess_dc(MpegEncContext *s, int16_t *dc, int w, int h, int stride, i
}
}
- for(b_y=0; b_y<h; b_y++){
- for(b_x=0; b_x<w; b_x++){
+ for (b_y = 0; b_y < h; b_y++) {
+ for (b_x = 0; b_x < w; b_x++) {
int mb_index, error, j;
int64_t guess, weight_sum;
-
- mb_index= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride;
-
- error= s->error_status_table[mb_index];
-
- if(IS_INTER(s->current_picture.f.mb_type[mb_index])) continue; //inter
- if(!(error&ER_DC_ERROR)) continue; //dc-ok
-
-
- weight_sum=0;
- guess=0;
- for(j=0; j<4; j++){
- int64_t weight= 256*256*256*16/dist[b_x + b_y*stride][j];
- guess+= weight*(int64_t)col[b_x + b_y*stride][j];
- weight_sum+= weight;
+ mb_index = (b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride;
+ error = s->error_status_table[mb_index];
+
+ if (IS_INTER(s->current_picture.f.mb_type[mb_index]))
+ continue; // inter
+ if (!(error & ER_DC_ERROR))
+ continue; // dc-ok
+
+ weight_sum = 0;
+ guess = 0;
+ for (j = 0; j < 4; j++) {
+ int64_t weight = 256 * 256 * 256 * 16 / dist[b_x + b_y*stride][j];
+ guess += weight*(int64_t)col[b_x + b_y*stride][j];
+ weight_sum += weight;
}
- guess= (guess + weight_sum/2) / weight_sum;
-
- dc[b_x + b_y*stride]= guess;
+ guess = (guess + weight_sum / 2) / weight_sum;
+ dc[b_x + b_y * stride] = guess;
}
}
av_freep(&col);
@@ -252,58 +262,63 @@ static void guess_dc(MpegEncContext *s, int16_t *dc, int w, int h, int stride, i
* @param w width in 8 pixel blocks
* @param h height in 8 pixel blocks
*/
-static void h_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int stride, int is_luma){
+static void h_block_filter(MpegEncContext *s, uint8_t *dst, int w,
+ int h, int stride, int is_luma)
+{
int b_x, b_y, mvx_stride, mvy_stride;
uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
set_mv_strides(s, &mvx_stride, &mvy_stride);
mvx_stride >>= is_luma;
mvy_stride *= mvx_stride;
- for(b_y=0; b_y<h; b_y++){
- for(b_x=0; b_x<w-1; b_x++){
+ for (b_y = 0; b_y < h; b_y++) {
+ for (b_x = 0; b_x < w - 1; b_x++) {
int y;
- int left_status = s->error_status_table[( b_x >>is_luma) + (b_y>>is_luma)*s->mb_stride];
- int right_status= s->error_status_table[((b_x+1)>>is_luma) + (b_y>>is_luma)*s->mb_stride];
- int left_intra = IS_INTRA(s->current_picture.f.mb_type[( b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride]);
- int right_intra = IS_INTRA(s->current_picture.f.mb_type[((b_x + 1) >> is_luma) + (b_y >> is_luma) * s->mb_stride]);
- int left_damage = left_status&ER_MB_ERROR;
- int right_damage= right_status&ER_MB_ERROR;
- int offset= b_x*8 + b_y*stride*8;
- int16_t *left_mv= s->current_picture.f.motion_val[0][mvy_stride*b_y + mvx_stride* b_x ];
- int16_t *right_mv= s->current_picture.f.motion_val[0][mvy_stride*b_y + mvx_stride*(b_x+1)];
-
- if(!(left_damage||right_damage)) continue; // both undamaged
-
- if( (!left_intra) && (!right_intra)
- && FFABS(left_mv[0]-right_mv[0]) + FFABS(left_mv[1]+right_mv[1]) < 2) continue;
-
- for(y=0; y<8; y++){
- int a,b,c,d;
-
- a= dst[offset + 7 + y*stride] - dst[offset + 6 + y*stride];
- b= dst[offset + 8 + y*stride] - dst[offset + 7 + y*stride];
- c= dst[offset + 9 + y*stride] - dst[offset + 8 + y*stride];
-
- d= FFABS(b) - ((FFABS(a) + FFABS(c) + 1)>>1);
- d= FFMAX(d, 0);
- if(b<0) d= -d;
-
- if(d==0) continue;
-
- if(!(left_damage && right_damage))
- d= d*16/9;
-
- if(left_damage){
- dst[offset + 7 + y*stride] = cm[dst[offset + 7 + y*stride] + ((d*7)>>4)];
- dst[offset + 6 + y*stride] = cm[dst[offset + 6 + y*stride] + ((d*5)>>4)];
- dst[offset + 5 + y*stride] = cm[dst[offset + 5 + y*stride] + ((d*3)>>4)];
- dst[offset + 4 + y*stride] = cm[dst[offset + 4 + y*stride] + ((d*1)>>4)];
+ int left_status = s->error_status_table[( b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride];
+ int right_status = s->error_status_table[((b_x + 1) >> is_luma) + (b_y >> is_luma) * s->mb_stride];
+ int left_intra = IS_INTRA(s->current_picture.f.mb_type[( b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride]);
+ int right_intra = IS_INTRA(s->current_picture.f.mb_type[((b_x + 1) >> is_luma) + (b_y >> is_luma) * s->mb_stride]);
+ int left_damage = left_status & ER_MB_ERROR;
+ int right_damage = right_status & ER_MB_ERROR;
+ int offset = b_x * 8 + b_y * stride * 8;
+ int16_t *left_mv = s->current_picture.f.motion_val[0][mvy_stride * b_y + mvx_stride * b_x];
+ int16_t *right_mv = s->current_picture.f.motion_val[0][mvy_stride * b_y + mvx_stride * (b_x + 1)];
+ if (!(left_damage || right_damage))
+ continue; // both undamaged
+ if ((!left_intra) && (!right_intra) &&
+ FFABS(left_mv[0] - right_mv[0]) +
+ FFABS(left_mv[1] + right_mv[1]) < 2)
+ continue;
+
+ for (y = 0; y < 8; y++) {
+ int a, b, c, d;
+
+ a = dst[offset + 7 + y * stride] - dst[offset + 6 + y * stride];
+ b = dst[offset + 8 + y * stride] - dst[offset + 7 + y * stride];
+ c = dst[offset + 9 + y * stride] - dst[offset + 8 + y * stride];
+
+ d = FFABS(b) - ((FFABS(a) + FFABS(c) + 1) >> 1);
+ d = FFMAX(d, 0);
+ if (b < 0)
+ d = -d;
+
+ if (d == 0)
+ continue;
+
+ if (!(left_damage && right_damage))
+ d = d * 16 / 9;
+
+ if (left_damage) {
+ dst[offset + 7 + y * stride] = cm[dst[offset + 7 + y * stride] + ((d * 7) >> 4)];
+ dst[offset + 6 + y * stride] = cm[dst[offset + 6 + y * stride] + ((d * 5) >> 4)];
+ dst[offset + 5 + y * stride] = cm[dst[offset + 5 + y * stride] + ((d * 3) >> 4)];
+ dst[offset + 4 + y * stride] = cm[dst[offset + 4 + y * stride] + ((d * 1) >> 4)];
}
- if(right_damage){
- dst[offset + 8 + y*stride] = cm[dst[offset + 8 + y*stride] - ((d*7)>>4)];
- dst[offset + 9 + y*stride] = cm[dst[offset + 9 + y*stride] - ((d*5)>>4)];
- dst[offset + 10+ y*stride] = cm[dst[offset +10 + y*stride] - ((d*3)>>4)];
- dst[offset + 11+ y*stride] = cm[dst[offset +11 + y*stride] - ((d*1)>>4)];
+ if (right_damage) {
+ dst[offset + 8 + y * stride] = cm[dst[offset + 8 + y * stride] - ((d * 7) >> 4)];
+ dst[offset + 9 + y * stride] = cm[dst[offset + 9 + y * stride] - ((d * 5) >> 4)];
+ dst[offset + 10+ y * stride] = cm[dst[offset + 10 + y * stride] - ((d * 3) >> 4)];
+ dst[offset + 11+ y * stride] = cm[dst[offset + 11 + y * stride] - ((d * 1) >> 4)];
}
}
}
@@ -315,88 +330,99 @@ static void h_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int st
* @param w width in 8 pixel blocks
* @param h height in 8 pixel blocks
*/
-static void v_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int stride, int is_luma){
+static void v_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h,
+ int stride, int is_luma)
+{
int b_x, b_y, mvx_stride, mvy_stride;
uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
set_mv_strides(s, &mvx_stride, &mvy_stride);
mvx_stride >>= is_luma;
mvy_stride *= mvx_stride;
- for(b_y=0; b_y<h-1; b_y++){
- for(b_x=0; b_x<w; b_x++){
+ for (b_y = 0; b_y < h - 1; b_y++) {
+ for (b_x = 0; b_x < w; b_x++) {
int x;
- int top_status = s->error_status_table[(b_x>>is_luma) + ( b_y >>is_luma)*s->mb_stride];
- int bottom_status= s->error_status_table[(b_x>>is_luma) + ((b_y+1)>>is_luma)*s->mb_stride];
- int top_intra = IS_INTRA(s->current_picture.f.mb_type[(b_x >> is_luma) + ( b_y >> is_luma) * s->mb_stride]);
- int bottom_intra = IS_INTRA(s->current_picture.f.mb_type[(b_x >> is_luma) + ((b_y + 1) >> is_luma) * s->mb_stride]);
- int top_damage = top_status&ER_MB_ERROR;
- int bottom_damage= bottom_status&ER_MB_ERROR;
- int offset= b_x*8 + b_y*stride*8;
+ int top_status = s->error_status_table[(b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride];
+ int bottom_status = s->error_status_table[(b_x >> is_luma) + ((b_y + 1) >> is_luma) * s->mb_stride];
+ int top_intra = IS_INTRA(s->current_picture.f.mb_type[(b_x >> is_luma) + ( b_y >> is_luma) * s->mb_stride]);
+ int bottom_intra = IS_INTRA(s->current_picture.f.mb_type[(b_x >> is_luma) + ((b_y + 1) >> is_luma) * s->mb_stride]);
+ int top_damage = top_status & ER_MB_ERROR;
+ int bottom_damage = bottom_status & ER_MB_ERROR;
+ int offset = b_x * 8 + b_y * stride * 8;
+
int16_t *top_mv = s->current_picture.f.motion_val[0][mvy_stride * b_y + mvx_stride * b_x];
int16_t *bottom_mv = s->current_picture.f.motion_val[0][mvy_stride * (b_y + 1) + mvx_stride * b_x];
- if(!(top_damage||bottom_damage)) continue; // both undamaged
+ if (!(top_damage || bottom_damage))
+ continue; // both undamaged
- if( (!top_intra) && (!bottom_intra)
- && FFABS(top_mv[0]-bottom_mv[0]) + FFABS(top_mv[1]+bottom_mv[1]) < 2) continue;
+ if ((!top_intra) && (!bottom_intra) &&
+ FFABS(top_mv[0] - bottom_mv[0]) +
+ FFABS(top_mv[1] + bottom_mv[1]) < 2)
+ continue;
- for(x=0; x<8; x++){
- int a,b,c,d;
+ for (x = 0; x < 8; x++) {
+ int a, b, c, d;
- a= dst[offset + x + 7*stride] - dst[offset + x + 6*stride];
- b= dst[offset + x + 8*stride] - dst[offset + x + 7*stride];
- c= dst[offset + x + 9*stride] - dst[offset + x + 8*stride];
+ a = dst[offset + x + 7 * stride] - dst[offset + x + 6 * stride];
+ b = dst[offset + x + 8 * stride] - dst[offset + x + 7 * stride];
+ c = dst[offset + x + 9 * stride] - dst[offset + x + 8 * stride];
- d= FFABS(b) - ((FFABS(a) + FFABS(c)+1)>>1);
- d= FFMAX(d, 0);
- if(b<0) d= -d;
+ d = FFABS(b) - ((FFABS(a) + FFABS(c) + 1) >> 1);
+ d = FFMAX(d, 0);
+ if (b < 0)
+ d = -d;
- if(d==0) continue;
+ if (d == 0)
+ continue;
- if(!(top_damage && bottom_damage))
- d= d*16/9;
+ if (!(top_damage && bottom_damage))
+ d = d * 16 / 9;
- if(top_damage){
- dst[offset + x + 7*stride] = cm[dst[offset + x + 7*stride] + ((d*7)>>4)];
- dst[offset + x + 6*stride] = cm[dst[offset + x + 6*stride] + ((d*5)>>4)];
- dst[offset + x + 5*stride] = cm[dst[offset + x + 5*stride] + ((d*3)>>4)];
- dst[offset + x + 4*stride] = cm[dst[offset + x + 4*stride] + ((d*1)>>4)];
+ if (top_damage) {
+ dst[offset + x + 7 * stride] = cm[dst[offset + x + 7 * stride] + ((d * 7) >> 4)];
+ dst[offset + x + 6 * stride] = cm[dst[offset + x + 6 * stride] + ((d * 5) >> 4)];
+ dst[offset + x + 5 * stride] = cm[dst[offset + x + 5 * stride] + ((d * 3) >> 4)];
+ dst[offset + x + 4 * stride] = cm[dst[offset + x + 4 * stride] + ((d * 1) >> 4)];
}
- if(bottom_damage){
- dst[offset + x + 8*stride] = cm[dst[offset + x + 8*stride] - ((d*7)>>4)];
- dst[offset + x + 9*stride] = cm[dst[offset + x + 9*stride] - ((d*5)>>4)];
- dst[offset + x + 10*stride] = cm[dst[offset + x + 10*stride] - ((d*3)>>4)];
- dst[offset + x + 11*stride] = cm[dst[offset + x + 11*stride] - ((d*1)>>4)];
+ if (bottom_damage) {
+ dst[offset + x + 8 * stride] = cm[dst[offset + x + 8 * stride] - ((d * 7) >> 4)];
+ dst[offset + x + 9 * stride] = cm[dst[offset + x + 9 * stride] - ((d * 5) >> 4)];
+ dst[offset + x + 10 * stride] = cm[dst[offset + x + 10 * stride] - ((d * 3) >> 4)];
+ dst[offset + x + 11 * stride] = cm[dst[offset + x + 11 * stride] - ((d * 1) >> 4)];
}
}
}
}
}
-static void guess_mv(MpegEncContext *s){
+static void guess_mv(MpegEncContext *s)
+{
uint8_t *fixed = av_malloc(s->mb_stride * s->mb_height);
#define MV_FROZEN 3
#define MV_CHANGED 2
#define MV_UNCHANGED 1
const int mb_stride = s->mb_stride;
- const int mb_width = s->mb_width;
- const int mb_height= s->mb_height;
+ const int mb_width = s->mb_width;
+ const int mb_height = s->mb_height;
int i, depth, num_avail;
int mb_x, mb_y, mot_step, mot_stride;
set_mv_strides(s, &mot_step, &mot_stride);
- num_avail=0;
- for(i=0; i<s->mb_num; i++){
- const int mb_xy= s->mb_index2xy[ i ];
- int f=0;
- int error= s->error_status_table[mb_xy];
+ num_avail = 0;
+ for (i = 0; i < s->mb_num; i++) {
+ const int mb_xy = s->mb_index2xy[i];
+ int f = 0;
+ int error = s->error_status_table[mb_xy];
- if(IS_INTRA(s->current_picture.f.mb_type[mb_xy])) f=MV_FROZEN; //intra //FIXME check
- if(!(error&ER_MV_ERROR)) f=MV_FROZEN; //inter with undamaged MV
+ if (IS_INTRA(s->current_picture.f.mb_type[mb_xy]))
+ f = MV_FROZEN; // intra // FIXME check
+ if (!(error & ER_MV_ERROR))
+ f = MV_FROZEN; // inter with undamaged MV
- fixed[mb_xy]= f;
- if(f==MV_FROZEN)
+ fixed[mb_xy] = f;
+ if (f == MV_FROZEN)
num_avail++;
else if(s->last_picture.f.data[0] && s->last_picture.f.motion_val[0]){
const int mb_y= mb_xy / s->mb_stride;
@@ -408,146 +434,175 @@ static void guess_mv(MpegEncContext *s){
}
}
- if((!(s->avctx->error_concealment&FF_EC_GUESS_MVS)) || num_avail <= mb_width/2){
- for(mb_y=0; mb_y<s->mb_height; mb_y++){
- for(mb_x=0; mb_x<s->mb_width; mb_x++){
- const int mb_xy= mb_x + mb_y*s->mb_stride;
+ if ((!(s->avctx->error_concealment&FF_EC_GUESS_MVS)) ||
+ num_avail <= mb_width / 2) {
+ for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
+ for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
+ const int mb_xy = mb_x + mb_y * s->mb_stride;
- if(IS_INTRA(s->current_picture.f.mb_type[mb_xy])) continue;
- if(!(s->error_status_table[mb_xy]&ER_MV_ERROR)) continue;
+ if (IS_INTRA(s->current_picture.f.mb_type[mb_xy]))
+ continue;
+ if (!(s->error_status_table[mb_xy] & ER_MV_ERROR))
+ continue;
- s->mv_dir = s->last_picture.f.data[0] ? MV_DIR_FORWARD : MV_DIR_BACKWARD;
- s->mb_intra=0;
- s->mv_type = MV_TYPE_16X16;
- s->mb_skipped=0;
+ s->mv_dir = s->last_picture.f.data[0] ? MV_DIR_FORWARD
+ : MV_DIR_BACKWARD;
+ s->mb_intra = 0;
+ s->mv_type = MV_TYPE_16X16;
+ s->mb_skipped = 0;
s->dsp.clear_blocks(s->block[0]);
- s->mb_x= mb_x;
- s->mb_y= mb_y;
- s->mv[0][0][0]= 0;
- s->mv[0][0][1]= 0;
+ s->mb_x = mb_x;
+ s->mb_y = mb_y;
+ s->mv[0][0][0] = 0;
+ s->mv[0][0][1] = 0;
decode_mb(s, 0);
}
}
goto end;
}
- for(depth=0;; depth++){
+ for (depth = 0; ; depth++) {
int changed, pass, none_left;
- none_left=1;
- changed=1;
- for(pass=0; (changed || pass<2) && pass<10; pass++){
+ none_left = 1;
+ changed = 1;
+ for (pass = 0; (changed || pass < 2) && pass < 10; pass++) {
int mb_x, mb_y;
-int score_sum=0;
-
- changed=0;
- for(mb_y=0; mb_y<s->mb_height; mb_y++){
- for(mb_x=0; mb_x<s->mb_width; mb_x++){
- const int mb_xy= mb_x + mb_y*s->mb_stride;
- int mv_predictor[8][2]={{0}};
- int ref[8]={0};
- int pred_count=0;
+ int score_sum = 0;
+
+ changed = 0;
+ for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
+ for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
+ const int mb_xy = mb_x + mb_y * s->mb_stride;
+ int mv_predictor[8][2] = { { 0 } };
+ int ref[8] = { 0 };
+ int pred_count = 0;
int j;
- int best_score=256*256*256*64;
- int best_pred=0;
- const int mot_index= (mb_x + mb_y*mot_stride) * mot_step;
+ int best_score = 256 * 256 * 256 * 64;
+ int best_pred = 0;
+ const int mot_index = (mb_x + mb_y * mot_stride) * mot_step;
int prev_x, prev_y, prev_ref;
- if((mb_x^mb_y^pass)&1) continue;
+ if ((mb_x ^ mb_y ^ pass) & 1)
+ continue;
- if(fixed[mb_xy]==MV_FROZEN) continue;
+ if (fixed[mb_xy] == MV_FROZEN)
+ continue;
assert(!IS_INTRA(s->current_picture.f.mb_type[mb_xy]));
assert(s->last_picture_ptr && s->last_picture_ptr->f.data[0]);
- j=0;
- if(mb_x>0 && fixed[mb_xy-1 ]==MV_FROZEN) j=1;
- if(mb_x+1<mb_width && fixed[mb_xy+1 ]==MV_FROZEN) j=1;
- if(mb_y>0 && fixed[mb_xy-mb_stride]==MV_FROZEN) j=1;
- if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]==MV_FROZEN) j=1;
- if(j==0) continue;
-
- j=0;
- if(mb_x>0 && fixed[mb_xy-1 ]==MV_CHANGED) j=1;
- if(mb_x+1<mb_width && fixed[mb_xy+1 ]==MV_CHANGED) j=1;
- if(mb_y>0 && fixed[mb_xy-mb_stride]==MV_CHANGED) j=1;
- if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]==MV_CHANGED) j=1;
- if(j==0 && pass>1) continue;
-
- none_left=0;
-
- if(mb_x>0 && fixed[mb_xy-1]){
- mv_predictor[pred_count][0]= s->current_picture.f.motion_val[0][mot_index - mot_step][0];
- mv_predictor[pred_count][1]= s->current_picture.f.motion_val[0][mot_index - mot_step][1];
- ref [pred_count] = s->current_picture.f.ref_index[0][4*(mb_xy-1)];
+ j = 0;
+ if (mb_x > 0 && fixed[mb_xy - 1] == MV_FROZEN)
+ j = 1;
+ if (mb_x + 1 < mb_width && fixed[mb_xy + 1] == MV_FROZEN)
+ j = 1;
+ if (mb_y > 0 && fixed[mb_xy - mb_stride] == MV_FROZEN)
+ j = 1;
+ if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] == MV_FROZEN)
+ j = 1;
+ if (j == 0)
+ continue;
+
+ j = 0;
+ if (mb_x > 0 && fixed[mb_xy - 1 ] == MV_CHANGED)
+ j = 1;
+ if (mb_x + 1 < mb_width && fixed[mb_xy + 1 ] == MV_CHANGED)
+ j = 1;
+ if (mb_y > 0 && fixed[mb_xy - mb_stride] == MV_CHANGED)
+ j = 1;
+ if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] == MV_CHANGED)
+ j = 1;
+ if (j == 0 && pass > 1)
+ continue;
+
+ none_left = 0;
+
+ if (mb_x > 0 && fixed[mb_xy - 1]) {
+ mv_predictor[pred_count][0] =
+ s->current_picture.f.motion_val[0][mot_index - mot_step][0];
+ mv_predictor[pred_count][1] =
+ s->current_picture.f.motion_val[0][mot_index - mot_step][1];
+ ref[pred_count] =
+ s->current_picture.f.ref_index[0][4 * (mb_xy - 1)];
pred_count++;
}
- if(mb_x+1<mb_width && fixed[mb_xy+1]){
- mv_predictor[pred_count][0]= s->current_picture.f.motion_val[0][mot_index + mot_step][0];
- mv_predictor[pred_count][1]= s->current_picture.f.motion_val[0][mot_index + mot_step][1];
- ref [pred_count] = s->current_picture.f.ref_index[0][4*(mb_xy+1)];
+ if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) {
+ mv_predictor[pred_count][0] =
+ s->current_picture.f.motion_val[0][mot_index + mot_step][0];
+ mv_predictor[pred_count][1] =
+ s->current_picture.f.motion_val[0][mot_index + mot_step][1];
+ ref[pred_count] =
+ s->current_picture.f.ref_index[0][4 * (mb_xy + 1)];
pred_count++;
}
- if(mb_y>0 && fixed[mb_xy-mb_stride]){
- mv_predictor[pred_count][0]= s->current_picture.f.motion_val[0][mot_index - mot_stride*mot_step][0];
- mv_predictor[pred_count][1]= s->current_picture.f.motion_val[0][mot_index - mot_stride*mot_step][1];
- ref [pred_count] = s->current_picture.f.ref_index[0][4*(mb_xy-s->mb_stride)];
+ if (mb_y > 0 && fixed[mb_xy - mb_stride]) {
+ mv_predictor[pred_count][0] =
+ s->current_picture.f.motion_val[0][mot_index - mot_stride * mot_step][0];
+ mv_predictor[pred_count][1] =
+ s->current_picture.f.motion_val[0][mot_index - mot_stride * mot_step][1];
+ ref[pred_count] =
+ s->current_picture.f.ref_index[0][4 * (mb_xy - s->mb_stride)];
pred_count++;
}
- if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]){
- mv_predictor[pred_count][0]= s->current_picture.f.motion_val[0][mot_index + mot_stride*mot_step][0];
- mv_predictor[pred_count][1]= s->current_picture.f.motion_val[0][mot_index + mot_stride*mot_step][1];
- ref [pred_count] = s->current_picture.f.ref_index[0][4*(mb_xy+s->mb_stride)];
+ if (mb_y + 1<mb_height && fixed[mb_xy + mb_stride]) {
+ mv_predictor[pred_count][0] =
+ s->current_picture.f.motion_val[0][mot_index + mot_stride * mot_step][0];
+ mv_predictor[pred_count][1] =
+ s->current_picture.f.motion_val[0][mot_index + mot_stride * mot_step][1];
+ ref[pred_count] =
+ s->current_picture.f.ref_index[0][4 * (mb_xy + s->mb_stride)];
pred_count++;
}
- if(pred_count==0) continue;
+ if (pred_count == 0)
+ continue;
- if(pred_count>1){
- int sum_x=0, sum_y=0, sum_r=0;
+ if (pred_count > 1) {
+ int sum_x = 0, sum_y = 0, sum_r = 0;
int max_x, max_y, min_x, min_y, max_r, min_r;
- for(j=0; j<pred_count; j++){
- sum_x+= mv_predictor[j][0];
- sum_y+= mv_predictor[j][1];
- sum_r+= ref[j];
- if(j && ref[j] != ref[j-1])
+ for (j = 0; j < pred_count; j++) {
+ sum_x += mv_predictor[j][0];
+ sum_y += mv_predictor[j][1];
+ sum_r += ref[j];
+ if (j && ref[j] != ref[j - 1])
goto skip_mean_and_median;
}
/* mean */
- mv_predictor[pred_count][0] = sum_x/j;
- mv_predictor[pred_count][1] = sum_y/j;
- ref [pred_count] = sum_r/j;
+ mv_predictor[pred_count][0] = sum_x / j;
+ mv_predictor[pred_count][1] = sum_y / j;
+ ref[pred_count] = sum_r / j;
/* median */
- if(pred_count>=3){
- min_y= min_x= min_r= 99999;
- max_y= max_x= max_r=-99999;
- }else{
- min_x=min_y=max_x=max_y=min_r=max_r=0;
+ if (pred_count >= 3) {
+ min_y = min_x = min_r = 99999;
+ max_y = max_x = max_r = -99999;
+ } else {
+ min_x = min_y = max_x = max_y = min_r = max_r = 0;
}
- for(j=0; j<pred_count; j++){
- max_x= FFMAX(max_x, mv_predictor[j][0]);
- max_y= FFMAX(max_y, mv_predictor[j][1]);
- max_r= FFMAX(max_r, ref[j]);
- min_x= FFMIN(min_x, mv_predictor[j][0]);
- min_y= FFMIN(min_y, mv_predictor[j][1]);
- min_r= FFMIN(min_r, ref[j]);
+ for (j = 0; j < pred_count; j++) {
+ max_x = FFMAX(max_x, mv_predictor[j][0]);
+ max_y = FFMAX(max_y, mv_predictor[j][1]);
+ max_r = FFMAX(max_r, ref[j]);
+ min_x = FFMIN(min_x, mv_predictor[j][0]);
+ min_y = FFMIN(min_y, mv_predictor[j][1]);
+ min_r = FFMIN(min_r, ref[j]);
}
- mv_predictor[pred_count+1][0] = sum_x - max_x - min_x;
- mv_predictor[pred_count+1][1] = sum_y - max_y - min_y;
- ref [pred_count+1] = sum_r - max_r - min_r;
-
- if(pred_count==4){
- mv_predictor[pred_count+1][0] /= 2;
- mv_predictor[pred_count+1][1] /= 2;
- ref [pred_count+1] /= 2;
+ mv_predictor[pred_count + 1][0] = sum_x - max_x - min_x;
+ mv_predictor[pred_count + 1][1] = sum_y - max_y - min_y;
+ ref[pred_count + 1] = sum_r - max_r - min_r;
+
+ if (pred_count == 4) {
+ mv_predictor[pred_count + 1][0] /= 2;
+ mv_predictor[pred_count + 1][1] /= 2;
+ ref[pred_count + 1] /= 2;
}
- pred_count+=2;
+ pred_count += 2;
}
-skip_mean_and_median:
+skip_mean_and_median:
/* zero MV */
pred_count++;
@@ -561,76 +616,83 @@ skip_mean_and_median:
if (!s->last_picture.f.motion_val[0] ||
!s->last_picture.f.ref_index[0])
goto skip_last_mv;
- prev_x = s->last_picture.f.motion_val[0][mot_index][0];
- prev_y = s->last_picture.f.motion_val[0][mot_index][1];
- prev_ref = s->last_picture.f.ref_index[0][4*mb_xy];
+ prev_x = s->last_picture.f.motion_val[0][mot_index][0];
+ prev_y = s->last_picture.f.motion_val[0][mot_index][1];
+ prev_ref = s->last_picture.f.ref_index[0][4 * mb_xy];
} else {
- prev_x = s->current_picture.f.motion_val[0][mot_index][0];
- prev_y = s->current_picture.f.motion_val[0][mot_index][1];
- prev_ref = s->current_picture.f.ref_index[0][4*mb_xy];
+ prev_x = s->current_picture.f.motion_val[0][mot_index][0];
+ prev_y = s->current_picture.f.motion_val[0][mot_index][1];
+ prev_ref = s->current_picture.f.ref_index[0][4 * mb_xy];
}
/* last MV */
- mv_predictor[pred_count][0]= prev_x;
- mv_predictor[pred_count][1]= prev_y;
- ref [pred_count] = prev_ref;
+ mv_predictor[pred_count][0] = prev_x;
+ mv_predictor[pred_count][1] = prev_y;
+ ref[pred_count] = prev_ref;
pred_count++;
- skip_last_mv:
- s->mv_dir = MV_DIR_FORWARD;
- s->mb_intra=0;
- s->mv_type = MV_TYPE_16X16;
- s->mb_skipped=0;
+skip_last_mv:
+ s->mv_dir = MV_DIR_FORWARD;
+ s->mb_intra = 0;
+ s->mv_type = MV_TYPE_16X16;
+ s->mb_skipped = 0;
s->dsp.clear_blocks(s->block[0]);
- s->mb_x= mb_x;
- s->mb_y= mb_y;
+ s->mb_x = mb_x;
+ s->mb_y = mb_y;
- for(j=0; j<pred_count; j++){
- int score=0;
- uint8_t *src = s->current_picture.f.data[0] + mb_x*16 + mb_y*16*s->linesize;
+ for (j = 0; j < pred_count; j++) {
+ int score = 0;
+ uint8_t *src = s->current_picture.f.data[0] +
+ mb_x * 16 + mb_y * 16 * s->linesize;
- s->current_picture.f.motion_val[0][mot_index][0] = s->mv[0][0][0] = mv_predictor[j][0];
- s->current_picture.f.motion_val[0][mot_index][1] = s->mv[0][0][1] = mv_predictor[j][1];
+ s->current_picture.f.motion_val[0][mot_index][0] =
+ s->mv[0][0][0] = mv_predictor[j][0];
+ s->current_picture.f.motion_val[0][mot_index][1] =
+ s->mv[0][0][1] = mv_predictor[j][1];
- if(ref[j]<0) //predictor intra or otherwise not available
+ // predictor intra or otherwise not available
+ if (ref[j] < 0)
continue;
decode_mb(s, ref[j]);
- if(mb_x>0 && fixed[mb_xy-1]){
+ if (mb_x > 0 && fixed[mb_xy - 1]) {
int k;
- for(k=0; k<16; k++)
- score += FFABS(src[k*s->linesize-1 ]-src[k*s->linesize ]);
+ for (k = 0; k < 16; k++)
+ score += FFABS(src[k * s->linesize - 1] -
+ src[k * s->linesize]);
}
- if(mb_x+1<mb_width && fixed[mb_xy+1]){
+ if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) {
int k;
- for(k=0; k<16; k++)
- score += FFABS(src[k*s->linesize+15]-src[k*s->linesize+16]);
+ for (k = 0; k < 16; k++)
+ score += FFABS(src[k * s->linesize + 15] -
+ src[k * s->linesize + 16]);
}
- if(mb_y>0 && fixed[mb_xy-mb_stride]){
+ if (mb_y > 0 && fixed[mb_xy - mb_stride]) {
int k;
- for(k=0; k<16; k++)
- score += FFABS(src[k-s->linesize ]-src[k ]);
+ for (k = 0; k < 16; k++)
+ score += FFABS(src[k - s->linesize] - src[k]);
}
- if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]){
+ if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride]) {
int k;
- for(k=0; k<16; k++)
- score += FFABS(src[k+s->linesize*15]-src[k+s->linesize*16]);
+ for (k = 0; k < 16; k++)
+ score += FFABS(src[k + s->linesize * 15] -
+ src[k + s->linesize * 16]);
}
- if(score <= best_score){ // <= will favor the last MV
- best_score= score;
- best_pred= j;
+ if (score <= best_score) { // <= will favor the last MV
+ best_score = score;
+ best_pred = j;
}
}
-score_sum+= best_score;
- s->mv[0][0][0]= mv_predictor[best_pred][0];
- s->mv[0][0][1]= mv_predictor[best_pred][1];
+ score_sum += best_score;
+ s->mv[0][0][0] = mv_predictor[best_pred][0];
+ s->mv[0][0][1] = mv_predictor[best_pred][1];
- for(i=0; i<mot_step; i++)
- for(j=0; j<mot_step; j++){
+ for (i = 0; i < mot_step; i++)
+ for (j = 0; j < mot_step; j++) {
s->current_picture.f.motion_val[0][mot_index + i + j * mot_stride][0] = s->mv[0][0][0];
s->current_picture.f.motion_val[0][mot_index + i + j * mot_stride][1] = s->mv[0][0][1];
}
@@ -638,75 +700,85 @@ score_sum+= best_score;
decode_mb(s, ref[best_pred]);
- if(s->mv[0][0][0] != prev_x || s->mv[0][0][1] != prev_y){
- fixed[mb_xy]=MV_CHANGED;
+ if (s->mv[0][0][0] != prev_x || s->mv[0][0][1] != prev_y) {
+ fixed[mb_xy] = MV_CHANGED;
changed++;
- }else
- fixed[mb_xy]=MV_UNCHANGED;
+ } else
+ fixed[mb_xy] = MV_UNCHANGED;
}
}
-// printf(".%d/%d", changed, score_sum); fflush(stdout);
+ // printf(".%d/%d", changed, score_sum); fflush(stdout);
}
- if(none_left)
+ if (none_left)
goto end;
- for(i=0; i<s->mb_num; i++){
- int mb_xy= s->mb_index2xy[i];
- if(fixed[mb_xy])
- fixed[mb_xy]=MV_FROZEN;
+ for (i = 0; i < s->mb_num; i++) {
+ int mb_xy = s->mb_index2xy[i];
+ if (fixed[mb_xy])
+ fixed[mb_xy] = MV_FROZEN;
}
-// printf(":"); fflush(stdout);
+ // printf(":"); fflush(stdout);
}
end:
av_free(fixed);
}
-static int is_intra_more_likely(MpegEncContext *s){
+static int is_intra_more_likely(MpegEncContext *s)
+{
int is_intra_likely, i, j, undamaged_count, skip_amount, mb_x, mb_y;
- if (!s->last_picture_ptr || !s->last_picture_ptr->f.data[0]) return 1; //no previous frame available -> use spatial prediction
+ if (!s->last_picture_ptr || !s->last_picture_ptr->f.data[0])
+ return 1; // no previous frame available -> use spatial prediction
- undamaged_count=0;
- for(i=0; i<s->mb_num; i++){
- const int mb_xy= s->mb_index2xy[i];
- const int error= s->error_status_table[mb_xy];
- if(!((error&ER_DC_ERROR) && (error&ER_MV_ERROR)))
+ undamaged_count = 0;
+ for (i = 0; i < s->mb_num; i++) {
+ const int mb_xy = s->mb_index2xy[i];
+ const int error = s->error_status_table[mb_xy];
+ if (!((error & ER_DC_ERROR) && (error & ER_MV_ERROR)))
undamaged_count++;
}
- if(s->codec_id == CODEC_ID_H264){
- H264Context *h= (void*)s;
- if (h->list_count <= 0 || h->ref_count[0] <= 0 || !h->ref_list[0][0].f.data[0])
+ if (s->codec_id == CODEC_ID_H264) {
+ H264Context *h = (void*) s;
+ if (h->list_count <= 0 || h->ref_count[0] <= 0 ||
+ !h->ref_list[0][0].f.data[0])
return 1;
}
- if(undamaged_count < 5) return 0; //almost all MBs damaged -> use temporal prediction
+ if (undamaged_count < 5)
+ return 0; // almost all MBs damaged -> use temporal prediction
- //prevent dsp.sad() check, that requires access to the image
- if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration && s->pict_type == AV_PICTURE_TYPE_I)
+ // prevent dsp.sad() check, that requires access to the image
+ if (CONFIG_MPEG_XVMC_DECODER &&
+ s->avctx->xvmc_acceleration &&
+ s->pict_type == AV_PICTURE_TYPE_I)
return 1;
- skip_amount = FFMAX(undamaged_count / 50, 1); // check only up to 50 MBs
- is_intra_likely=0;
+ skip_amount = FFMAX(undamaged_count / 50, 1); // check only up to 50 MBs
+ is_intra_likely = 0;
- j=0;
- for(mb_y= 0; mb_y<s->mb_height-1; mb_y++){
- for(mb_x= 0; mb_x<s->mb_width; mb_x++){
+ j = 0;
+ for (mb_y = 0; mb_y < s->mb_height - 1; mb_y++) {
+ for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
int error;
- const int mb_xy= mb_x + mb_y*s->mb_stride;
+ const int mb_xy = mb_x + mb_y * s->mb_stride;
- error= s->error_status_table[mb_xy];
- if((error&ER_DC_ERROR) && (error&ER_MV_ERROR))
- continue; //skip damaged
+ error = s->error_status_table[mb_xy];
+ if ((error & ER_DC_ERROR) && (error & ER_MV_ERROR))
+ continue; // skip damaged
j++;
- if((j%skip_amount) != 0) continue; //skip a few to speed things up
+ // skip a few to speed things up
+ if ((j % skip_amount) != 0)
+ continue;
- if(s->pict_type==AV_PICTURE_TYPE_I){
- uint8_t *mb_ptr = s->current_picture.f.data[0] + mb_x*16 + mb_y*16*s->linesize;
- uint8_t *last_mb_ptr= s->last_picture.f.data [0] + mb_x*16 + mb_y*16*s->linesize;
+ if (s->pict_type == AV_PICTURE_TYPE_I) {
+ uint8_t *mb_ptr = s->current_picture.f.data[0] +
+ mb_x * 16 + mb_y * 16 * s->linesize;
+ uint8_t *last_mb_ptr = s->last_picture.f.data[0] +
+ mb_x * 16 + mb_y * 16 * s->linesize;
if (s->avctx->codec_id == CODEC_ID_H264) {
// FIXME
@@ -717,7 +789,7 @@ static int is_intra_more_likely(MpegEncContext *s){
is_intra_likely += s->dsp.sad[0](NULL, last_mb_ptr, mb_ptr , s->linesize, 16);
// FIXME need await_progress() here
is_intra_likely -= s->dsp.sad[0](NULL, last_mb_ptr, last_mb_ptr+s->linesize*16, s->linesize, 16);
- }else{
+ } else {
if (IS_INTRA(s->current_picture.f.mb_type[mb_xy]))
is_intra_likely++;
else
@@ -725,117 +797,133 @@ static int is_intra_more_likely(MpegEncContext *s){
}
}
}
-//printf("is_intra_likely: %d type:%d\n", is_intra_likely, s->pict_type);
+ // printf("is_intra_likely: %d type:%d\n", is_intra_likely, s->pict_type);
return is_intra_likely > 0;
}
-void ff_er_frame_start(MpegEncContext *s){
- if(!s->err_recognition) return;
+void ff_er_frame_start(MpegEncContext *s)
+{
+ if (!s->err_recognition)
+ return;
- memset(s->error_status_table, ER_MB_ERROR|VP_START|ER_MB_END, s->mb_stride*s->mb_height*sizeof(uint8_t));
- s->error_count= 3*s->mb_num;
+ memset(s->error_status_table, ER_MB_ERROR | VP_START | ER_MB_END,
+ s->mb_stride * s->mb_height * sizeof(uint8_t));
+ s->error_count = 3 * s->mb_num;
s->error_occurred = 0;
}
/**
* Add a slice.
- * @param endx x component of the last macroblock, can be -1 for the last of the previous line
- * @param status the status at the end (ER_MV_END, ER_AC_ERROR, ...), it is assumed that no earlier end or
- * error of the same type occurred
+ * @param endx x component of the last macroblock, can be -1
+ * for the last of the previous line
+ * @param status the status at the end (ER_MV_END, ER_AC_ERROR, ...), it is
+ * assumed that no earlier end or error of the same type occurred
*/
-void ff_er_add_slice(MpegEncContext *s, int startx, int starty, int endx, int endy, int status){
- const int start_i= av_clip(startx + starty * s->mb_width , 0, s->mb_num-1);
- const int end_i = av_clip(endx + endy * s->mb_width , 0, s->mb_num);
- const int start_xy= s->mb_index2xy[start_i];
- const int end_xy = s->mb_index2xy[end_i];
- int mask= -1;
-
- if(s->avctx->hwaccel)
+void ff_er_add_slice(MpegEncContext *s, int startx, int starty,
+ int endx, int endy, int status)
+{
+ const int start_i = av_clip(startx + starty * s->mb_width, 0, s->mb_num - 1);
+ const int end_i = av_clip(endx + endy * s->mb_width, 0, s->mb_num);
+ const int start_xy = s->mb_index2xy[start_i];
+ const int end_xy = s->mb_index2xy[end_i];
+ int mask = -1;
+
+ if (s->avctx->hwaccel)
return;
- if(start_i > end_i || start_xy > end_xy){
- av_log(s->avctx, AV_LOG_ERROR, "internal error, slice end before start\n");
+ if (start_i > end_i || start_xy > end_xy) {
+ av_log(s->avctx, AV_LOG_ERROR,
+ "internal error, slice end before start\n");
return;
}
- if(!s->err_recognition) return;
+ if (!s->err_recognition)
+ return;
mask &= ~VP_START;
- if(status & (ER_AC_ERROR|ER_AC_END)){
- mask &= ~(ER_AC_ERROR|ER_AC_END);
+ if (status & (ER_AC_ERROR | ER_AC_END)) {
+ mask &= ~(ER_AC_ERROR | ER_AC_END);
s->error_count -= end_i - start_i + 1;
}
- if(status & (ER_DC_ERROR|ER_DC_END)){
- mask &= ~(ER_DC_ERROR|ER_DC_END);
+ if (status & (ER_DC_ERROR | ER_DC_END)) {
+ mask &= ~(ER_DC_ERROR | ER_DC_END);
s->error_count -= end_i - start_i + 1;
}
- if(status & (ER_MV_ERROR|ER_MV_END)){
- mask &= ~(ER_MV_ERROR|ER_MV_END);
+ if (status & (ER_MV_ERROR | ER_MV_END)) {
+ mask &= ~(ER_MV_ERROR | ER_MV_END);
s->error_count -= end_i - start_i + 1;
}
- if(status & ER_MB_ERROR) {
+ if (status & ER_MB_ERROR) {
s->error_occurred = 1;
- s->error_count= INT_MAX;
+ s->error_count = INT_MAX;
}
- if(mask == ~0x7F){
- memset(&s->error_status_table[start_xy], 0, (end_xy - start_xy) * sizeof(uint8_t));
- }else{
+ if (mask == ~0x7F) {
+ memset(&s->error_status_table[start_xy], 0,
+ (end_xy - start_xy) * sizeof(uint8_t));
+ } else {
int i;
- for(i=start_xy; i<end_xy; i++){
- s->error_status_table[ i ] &= mask;
- }
+ for (i = start_xy; i < end_xy; i++)
+ s->error_status_table[i] &= mask;
}
- if(end_i == s->mb_num)
- s->error_count= INT_MAX;
- else{
+ if (end_i == s->mb_num)
+ s->error_count = INT_MAX;
+ else {
s->error_status_table[end_xy] &= mask;
s->error_status_table[end_xy] |= status;
}
s->error_status_table[start_xy] |= VP_START;
- if(start_xy > 0 && s->avctx->thread_count <= 1 && s->avctx->skip_top*s->mb_width < start_i){
- int prev_status= s->error_status_table[ s->mb_index2xy[start_i - 1] ];
+ if (start_xy > 0 && s->avctx->thread_count <= 1 &&
+ s->avctx->skip_top * s->mb_width < start_i) {
+ int prev_status = s->error_status_table[s->mb_index2xy[start_i - 1]];
prev_status &= ~ VP_START;
- if(prev_status != (ER_MV_END|ER_DC_END|ER_AC_END)) s->error_count= INT_MAX;
+ if (prev_status != (ER_MV_END | ER_DC_END | ER_AC_END))
+ s->error_count = INT_MAX;
}
}
-void ff_er_frame_end(MpegEncContext *s){
+void ff_er_frame_end(MpegEncContext *s)
+{
int i, mb_x, mb_y, error, error_type, dc_error, mv_error, ac_error;
int distance;
- int threshold_part[4]= {100,100,100};
- int threshold= 50;
+ int threshold_part[4] = { 100, 100, 100 };
+ int threshold = 50;
int is_intra_likely;
int size = s->b8_stride * 2 * s->mb_height;
- Picture *pic= s->current_picture_ptr;
-
- if(!s->err_recognition || s->error_count==0 || s->avctx->lowres ||
- s->avctx->hwaccel ||
- s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU ||
- s->picture_structure != PICT_FRAME || // we do not support ER of field pictures yet, though it should not crash if enabled
- s->error_count==3*s->mb_width*(s->avctx->skip_top + s->avctx->skip_bottom)) return;
+ Picture *pic = s->current_picture_ptr;
+
+ /* We do not support ER of field pictures yet,
+ * though it should not crash if enabled. */
+ if (!s->err_recognition || s->error_count == 0 || s->avctx->lowres ||
+ s->avctx->hwaccel ||
+ s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU ||
+ s->picture_structure != PICT_FRAME ||
+ s->error_count == 3 * s->mb_width *
+ (s->avctx->skip_top + s->avctx->skip_bottom)) {
+ return;
+ };
if (s->current_picture.f.motion_val[0] == NULL) {
av_log(s->avctx, AV_LOG_ERROR, "Warning MVs not available\n");
- for(i=0; i<2; i++){
- pic->f.ref_index[i] = av_mallocz(s->mb_stride * s->mb_height * 4 * sizeof(uint8_t));
- pic->motion_val_base[i]= av_mallocz((size+4) * 2 * sizeof(uint16_t));
- pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
+ for (i = 0; i < 2; i++) {
+ pic->f.ref_index[i] = av_mallocz(s->mb_stride * s->mb_height * 4 * sizeof(uint8_t));
+ pic->motion_val_base[i] = av_mallocz((size + 4) * 2 * sizeof(uint16_t));
+ pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
}
pic->f.motion_subsample_log2 = 3;
- s->current_picture= *s->current_picture_ptr;
+ s->current_picture = *s->current_picture_ptr;
}
- if(s->avctx->debug&FF_DEBUG_ER){
- for(mb_y=0; mb_y<s->mb_height; mb_y++){
- for(mb_x=0; mb_x<s->mb_width; mb_x++){
- int status= s->error_status_table[mb_x + mb_y*s->mb_stride];
+ if (s->avctx->debug & FF_DEBUG_ER) {
+ for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
+ for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
+ int status = s->error_status_table[mb_x + mb_y * s->mb_stride];
av_log(s->avctx, AV_LOG_DEBUG, "%2X ", status);
}
@@ -845,144 +933,153 @@ void ff_er_frame_end(MpegEncContext *s){
#if 1
/* handle overlapping slices */
- for(error_type=1; error_type<=3; error_type++){
- int end_ok=0;
+ for (error_type = 1; error_type <= 3; error_type++) {
+ int end_ok = 0;
- for(i=s->mb_num-1; i>=0; i--){
- const int mb_xy= s->mb_index2xy[i];
- int error= s->error_status_table[mb_xy];
+ for (i = s->mb_num - 1; i >= 0; i--) {
+ const int mb_xy = s->mb_index2xy[i];
+ int error = s->error_status_table[mb_xy];
- if(error&(1<<error_type))
- end_ok=1;
- if(error&(8<<error_type))
- end_ok=1;
+ if (error & (1 << error_type))
+ end_ok = 1;
+ if (error & (8 << error_type))
+ end_ok = 1;
- if(!end_ok)
- s->error_status_table[mb_xy]|= 1<<error_type;
+ if (!end_ok)
+ s->error_status_table[mb_xy] |= 1 << error_type;
- if(error&VP_START)
- end_ok=0;
+ if (error & VP_START)
+ end_ok = 0;
}
}
#endif
#if 1
/* handle slices with partitions of different length */
- if(s->partitioned_frame){
- int end_ok=0;
+ if (s->partitioned_frame) {
+ int end_ok = 0;
- for(i=s->mb_num-1; i>=0; i--){
- const int mb_xy= s->mb_index2xy[i];
- int error= s->error_status_table[mb_xy];
+ for (i = s->mb_num - 1; i >= 0; i--) {
+ const int mb_xy = s->mb_index2xy[i];
+ int error = s->error_status_table[mb_xy];
- if(error&ER_AC_END)
- end_ok=0;
- if((error&ER_MV_END) || (error&ER_DC_END) || (error&ER_AC_ERROR))
- end_ok=1;
+ if (error & ER_AC_END)
+ end_ok = 0;
+ if ((error & ER_MV_END) ||
+ (error & ER_DC_END) ||
+ (error & ER_AC_ERROR))
+ end_ok = 1;
- if(!end_ok)
+ if (!end_ok)
s->error_status_table[mb_xy]|= ER_AC_ERROR;
- if(error&VP_START)
- end_ok=0;
+ if (error & VP_START)
+ end_ok = 0;
}
}
#endif
/* handle missing slices */
- if(s->err_recognition&AV_EF_EXPLODE){
- int end_ok=1;
-
- for(i=s->mb_num-2; i>=s->mb_width+100; i--){ //FIXME +100 hack
- const int mb_xy= s->mb_index2xy[i];
- int error1= s->error_status_table[mb_xy ];
- int error2= s->error_status_table[s->mb_index2xy[i+1]];
-
- if(error1&VP_START)
- end_ok=1;
-
- if( error2==(VP_START|ER_MB_ERROR|ER_MB_END)
- && error1!=(VP_START|ER_MB_ERROR|ER_MB_END)
- && ((error1&ER_AC_END) || (error1&ER_DC_END) || (error1&ER_MV_END))){ //end & uninit
- end_ok=0;
+ if (s->err_recognition & AV_EF_EXPLODE) {
+ int end_ok = 1;
+
+ // FIXME + 100 hack
+ for (i = s->mb_num - 2; i >= s->mb_width + 100; i--) {
+ const int mb_xy = s->mb_index2xy[i];
+ int error1 = s->error_status_table[mb_xy];
+ int error2 = s->error_status_table[s->mb_index2xy[i + 1]];
+
+ if (error1 & VP_START)
+ end_ok = 1;
+
+ if (error2 == (VP_START | ER_MB_ERROR | ER_MB_END) &&
+ error1 != (VP_START | ER_MB_ERROR | ER_MB_END) &&
+ ((error1 & ER_AC_END) || (error1 & ER_DC_END) ||
+ (error1 & ER_MV_END))) {
+ // end & uninit
+ end_ok = 0;
}
- if(!end_ok)
- s->error_status_table[mb_xy]|= ER_MB_ERROR;
+ if (!end_ok)
+ s->error_status_table[mb_xy] |= ER_MB_ERROR;
}
}
#if 1
/* backward mark errors */
- distance=9999999;
- for(error_type=1; error_type<=3; error_type++){
- for(i=s->mb_num-1; i>=0; i--){
- const int mb_xy= s->mb_index2xy[i];
- int error= s->error_status_table[mb_xy];
+ distance = 9999999;
+ for (error_type = 1; error_type <= 3; error_type++) {
+ for (i = s->mb_num - 1; i >= 0; i--) {
+ const int mb_xy = s->mb_index2xy[i];
+ int error = s->error_status_table[mb_xy];
- if(!s->mbskip_table[mb_xy]) //FIXME partition specific
+ if (!s->mbskip_table[mb_xy]) // FIXME partition specific
distance++;
- if(error&(1<<error_type))
- distance= 0;
-
- if(s->partitioned_frame){
- if(distance < threshold_part[error_type-1])
- s->error_status_table[mb_xy]|= 1<<error_type;
- }else{
- if(distance < threshold)
- s->error_status_table[mb_xy]|= 1<<error_type;
+ if (error & (1 << error_type))
+ distance = 0;
+
+ if (s->partitioned_frame) {
+ if (distance < threshold_part[error_type - 1])
+ s->error_status_table[mb_xy] |= 1 << error_type;
+ } else {
+ if (distance < threshold)
+ s->error_status_table[mb_xy] |= 1 << error_type;
}
- if(error&VP_START)
- distance= 9999999;
+ if (error & VP_START)
+ distance = 9999999;
}
}
#endif
/* forward mark errors */
- error=0;
- for(i=0; i<s->mb_num; i++){
- const int mb_xy= s->mb_index2xy[i];
- int old_error= s->error_status_table[mb_xy];
-
- if(old_error&VP_START)
- error= old_error& ER_MB_ERROR;
- else{
- error|= old_error& ER_MB_ERROR;
- s->error_status_table[mb_xy]|= error;
+ error = 0;
+ for (i = 0; i < s->mb_num; i++) {
+ const int mb_xy = s->mb_index2xy[i];
+ int old_error = s->error_status_table[mb_xy];
+
+ if (old_error & VP_START) {
+ error = old_error & ER_MB_ERROR;
+ } else {
+ error |= old_error & ER_MB_ERROR;
+ s->error_status_table[mb_xy] |= error;
}
}
#if 1
/* handle not partitioned case */
- if(!s->partitioned_frame){
- for(i=0; i<s->mb_num; i++){
- const int mb_xy= s->mb_index2xy[i];
- error= s->error_status_table[mb_xy];
- if(error&ER_MB_ERROR)
- error|= ER_MB_ERROR;
- s->error_status_table[mb_xy]= error;
+ if (!s->partitioned_frame) {
+ for (i = 0; i < s->mb_num; i++) {
+ const int mb_xy = s->mb_index2xy[i];
+ error = s->error_status_table[mb_xy];
+ if (error & ER_MB_ERROR)
+ error |= ER_MB_ERROR;
+ s->error_status_table[mb_xy] = error;
}
}
#endif
- dc_error= ac_error= mv_error=0;
- for(i=0; i<s->mb_num; i++){
- const int mb_xy= s->mb_index2xy[i];
- error= s->error_status_table[mb_xy];
- if(error&ER_DC_ERROR) dc_error ++;
- if(error&ER_AC_ERROR) ac_error ++;
- if(error&ER_MV_ERROR) mv_error ++;
+ dc_error = ac_error = mv_error = 0;
+ for (i = 0; i < s->mb_num; i++) {
+ const int mb_xy = s->mb_index2xy[i];
+ error = s->error_status_table[mb_xy];
+ if (error & ER_DC_ERROR)
+ dc_error++;
+ if (error & ER_AC_ERROR)
+ ac_error++;
+ if (error & ER_MV_ERROR)
+ mv_error++;
}
- av_log(s->avctx, AV_LOG_INFO, "concealing %d DC, %d AC, %d MV errors\n", dc_error, ac_error, mv_error);
+ av_log(s->avctx, AV_LOG_INFO, "concealing %d DC, %d AC, %d MV errors\n",
+ dc_error, ac_error, mv_error);
- is_intra_likely= is_intra_more_likely(s);
+ is_intra_likely = is_intra_more_likely(s);
/* set unknown mb-type to most likely */
- for(i=0; i<s->mb_num; i++){
- const int mb_xy= s->mb_index2xy[i];
- error= s->error_status_table[mb_xy];
- if(!((error&ER_DC_ERROR) && (error&ER_MV_ERROR)))
+ for (i = 0; i < s->mb_num; i++) {
+ const int mb_xy = s->mb_index2xy[i];
+ error = s->error_status_table[mb_xy];
+ if (!((error & ER_DC_ERROR) && (error & ER_MV_ERROR)))
continue;
- if(is_intra_likely)
+ if (is_intra_likely)
s->current_picture.f.mb_type[mb_xy] = MB_TYPE_INTRA4x4;
else
s->current_picture.f.mb_type[mb_xy] = MB_TYPE_16x16 | MB_TYPE_L0;
@@ -990,142 +1087,153 @@ void ff_er_frame_end(MpegEncContext *s){
// change inter to intra blocks if no reference frames are available
if (!s->last_picture.f.data[0] && !s->next_picture.f.data[0])
- for(i=0; i<s->mb_num; i++){
- const int mb_xy= s->mb_index2xy[i];
+ for (i = 0; i < s->mb_num; i++) {
+ const int mb_xy = s->mb_index2xy[i];
if (!IS_INTRA(s->current_picture.f.mb_type[mb_xy]))
s->current_picture.f.mb_type[mb_xy] = MB_TYPE_INTRA4x4;
}
/* handle inter blocks with damaged AC */
- for(mb_y=0; mb_y<s->mb_height; mb_y++){
- for(mb_x=0; mb_x<s->mb_width; mb_x++){
- const int mb_xy= mb_x + mb_y * s->mb_stride;
- const int mb_type= s->current_picture.f.mb_type[mb_xy];
- int dir = !s->last_picture.f.data[0];
- error= s->error_status_table[mb_xy];
-
- if(IS_INTRA(mb_type)) continue; //intra
- if(error&ER_MV_ERROR) continue; //inter with damaged MV
- if(!(error&ER_AC_ERROR)) continue; //undamaged inter
-
- s->mv_dir = dir ? MV_DIR_BACKWARD : MV_DIR_FORWARD;
- s->mb_intra=0;
- s->mb_skipped=0;
- if(IS_8X8(mb_type)){
- int mb_index= mb_x*2 + mb_y*2*s->b8_stride;
+ for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
+ for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
+ const int mb_xy = mb_x + mb_y * s->mb_stride;
+ const int mb_type = s->current_picture.f.mb_type[mb_xy];
+ int dir = !s->last_picture.f.data[0];
+
+ error = s->error_status_table[mb_xy];
+
+ if (IS_INTRA(mb_type))
+ continue; // intra
+ if (error & ER_MV_ERROR)
+ continue; // inter with damaged MV
+ if (!(error & ER_AC_ERROR))
+ continue; // undamaged inter
+
+ s->mv_dir = dir ? MV_DIR_BACKWARD : MV_DIR_FORWARD;
+ s->mb_intra = 0;
+ s->mb_skipped = 0;
+ if (IS_8X8(mb_type)) {
+ int mb_index = mb_x * 2 + mb_y * 2 * s->b8_stride;
int j;
s->mv_type = MV_TYPE_8X8;
- for(j=0; j<4; j++){
+ for (j = 0; j < 4; j++) {
s->mv[0][j][0] = s->current_picture.f.motion_val[dir][mb_index + (j & 1) + (j >> 1) * s->b8_stride][0];
s->mv[0][j][1] = s->current_picture.f.motion_val[dir][mb_index + (j & 1) + (j >> 1) * s->b8_stride][1];
}
- }else{
- s->mv_type = MV_TYPE_16X16;
- s->mv[0][0][0] = s->current_picture.f.motion_val[dir][ mb_x*2 + mb_y*2*s->b8_stride ][0];
- s->mv[0][0][1] = s->current_picture.f.motion_val[dir][ mb_x*2 + mb_y*2*s->b8_stride ][1];
+ } else {
+ s->mv_type = MV_TYPE_16X16;
+ s->mv[0][0][0] = s->current_picture.f.motion_val[dir][mb_x * 2 + mb_y * 2 * s->b8_stride][0];
+ s->mv[0][0][1] = s->current_picture.f.motion_val[dir][mb_x * 2 + mb_y * 2 * s->b8_stride][1];
}
s->dsp.clear_blocks(s->block[0]);
- s->mb_x= mb_x;
- s->mb_y= mb_y;
- decode_mb(s, 0/*FIXME h264 partitioned slices need this set*/);
+ s->mb_x = mb_x;
+ s->mb_y = mb_y;
+ decode_mb(s, 0 /* FIXME h264 partitioned slices need this set */);
}
}
/* guess MVs */
- if(s->pict_type==AV_PICTURE_TYPE_B){
- for(mb_y=0; mb_y<s->mb_height; mb_y++){
- for(mb_x=0; mb_x<s->mb_width; mb_x++){
- int xy= mb_x*2 + mb_y*2*s->b8_stride;
- const int mb_xy= mb_x + mb_y * s->mb_stride;
- const int mb_type= s->current_picture.f.mb_type[mb_xy];
- error= s->error_status_table[mb_xy];
-
- if(IS_INTRA(mb_type)) continue;
- if(!(error&ER_MV_ERROR)) continue; //inter with undamaged MV
- if(!(error&ER_AC_ERROR)) continue; //undamaged inter
-
- s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD;
- if(!s->last_picture.f.data[0]) s->mv_dir &= ~MV_DIR_FORWARD;
- if(!s->next_picture.f.data[0]) s->mv_dir &= ~MV_DIR_BACKWARD;
- s->mb_intra=0;
- s->mv_type = MV_TYPE_16X16;
- s->mb_skipped=0;
-
- if(s->pp_time){
- int time_pp= s->pp_time;
- int time_pb= s->pb_time;
+ if (s->pict_type == AV_PICTURE_TYPE_B) {
+ for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
+ for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
+ int xy = mb_x * 2 + mb_y * 2 * s->b8_stride;
+ const int mb_xy = mb_x + mb_y * s->mb_stride;
+ const int mb_type = s->current_picture.f.mb_type[mb_xy];
+
+ error = s->error_status_table[mb_xy];
+
+ if (IS_INTRA(mb_type))
+ continue;
+ if (!(error & ER_MV_ERROR))
+ continue; // inter with undamaged MV
+ if (!(error & ER_AC_ERROR))
+ continue; // undamaged inter
+
+ s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
+ if (!s->last_picture.f.data[0])
+ s->mv_dir &= ~MV_DIR_FORWARD;
+ if (!s->next_picture.f.data[0])
+ s->mv_dir &= ~MV_DIR_BACKWARD;
+ s->mb_intra = 0;
+ s->mv_type = MV_TYPE_16X16;
+ s->mb_skipped = 0;
+
+ if (s->pp_time) {
+ int time_pp = s->pp_time;
+ int time_pb = s->pb_time;
if (s->avctx->codec_id == CODEC_ID_H264) {
- //FIXME
+ // FIXME
} else {
- ff_thread_await_progress((AVFrame *) s->next_picture_ptr,
- mb_y, 0);
+ ff_thread_await_progress((AVFrame *) s->next_picture_ptr, mb_y, 0);
}
- s->mv[0][0][0] = s->next_picture.f.motion_val[0][xy][0] * time_pb / time_pp;
- s->mv[0][0][1] = s->next_picture.f.motion_val[0][xy][1] * time_pb / time_pp;
+ s->mv[0][0][0] = s->next_picture.f.motion_val[0][xy][0] * time_pb / time_pp;
+ s->mv[0][0][1] = s->next_picture.f.motion_val[0][xy][1] * time_pb / time_pp;
s->mv[1][0][0] = s->next_picture.f.motion_val[0][xy][0] * (time_pb - time_pp) / time_pp;
s->mv[1][0][1] = s->next_picture.f.motion_val[0][xy][1] * (time_pb - time_pp) / time_pp;
- }else{
- s->mv[0][0][0]= 0;
- s->mv[0][0][1]= 0;
- s->mv[1][0][0]= 0;
- s->mv[1][0][1]= 0;
+ } else {
+ s->mv[0][0][0] = 0;
+ s->mv[0][0][1] = 0;
+ s->mv[1][0][0] = 0;
+ s->mv[1][0][1] = 0;
}
s->dsp.clear_blocks(s->block[0]);
- s->mb_x= mb_x;
- s->mb_y= mb_y;
+ s->mb_x = mb_x;
+ s->mb_y = mb_y;
decode_mb(s, 0);
}
}
- }else
+ } else
guess_mv(s);
/* the filters below are not XvMC compatible, skip them */
- if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
+ if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
goto ec_clean;
/* fill DC for inter blocks */
- for(mb_y=0; mb_y<s->mb_height; mb_y++){
- for(mb_x=0; mb_x<s->mb_width; mb_x++){
+ for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
+ for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
int dc, dcu, dcv, y, n;
int16_t *dc_ptr;
uint8_t *dest_y, *dest_cb, *dest_cr;
- const int mb_xy= mb_x + mb_y * s->mb_stride;
+ const int mb_xy = mb_x + mb_y * s->mb_stride;
const int mb_type = s->current_picture.f.mb_type[mb_xy];
- error= s->error_status_table[mb_xy];
+ error = s->error_status_table[mb_xy];
- if(IS_INTRA(mb_type) && s->partitioned_frame) continue;
-// if(error&ER_MV_ERROR) continue; //inter data damaged FIXME is this good?
+ if (IS_INTRA(mb_type) && s->partitioned_frame)
+ continue;
+ // if (error & ER_MV_ERROR)
+ // continue; // inter data damaged FIXME is this good?
dest_y = s->current_picture.f.data[0] + mb_x * 16 + mb_y * 16 * s->linesize;
dest_cb = s->current_picture.f.data[1] + mb_x * 8 + mb_y * 8 * s->uvlinesize;
dest_cr = s->current_picture.f.data[2] + mb_x * 8 + mb_y * 8 * s->uvlinesize;
- dc_ptr= &s->dc_val[0][mb_x*2 + mb_y*2*s->b8_stride];
- for(n=0; n<4; n++){
- dc=0;
- for(y=0; y<8; y++){
+ dc_ptr = &s->dc_val[0][mb_x * 2 + mb_y * 2 * s->b8_stride];
+ for (n = 0; n < 4; n++) {
+ dc = 0;
+ for (y = 0; y < 8; y++) {
int x;
- for(x=0; x<8; x++){
- dc+= dest_y[x + (n&1)*8 + (y + (n>>1)*8)*s->linesize];
- }
+ for (x = 0; x < 8; x++)
+ dc += dest_y[x + (n & 1) * 8 +
+ (y + (n >> 1) * 8) * s->linesize];
}
- dc_ptr[(n&1) + (n>>1)*s->b8_stride]= (dc+4)>>3;
+ dc_ptr[(n & 1) + (n >> 1) * s->b8_stride] = (dc + 4) >> 3;
}
- dcu=dcv=0;
- for(y=0; y<8; y++){
+ dcu = dcv = 0;
+ for (y = 0; y < 8; y++) {
int x;
- for(x=0; x<8; x++){
+ for (x = 0; x < 8; x++) {
dcu += dest_cb[x + y * s->uvlinesize];
dcv += dest_cr[x + y * s->uvlinesize];
}
}
- s->dc_val[1][mb_x + mb_y*s->mb_stride]= (dcu+4)>>3;
- s->dc_val[2][mb_x + mb_y*s->mb_stride]= (dcv+4)>>3;
+ s->dc_val[1][mb_x + mb_y * s->mb_stride] = (dcu + 4) >> 3;
+ s->dc_val[2][mb_x + mb_y * s->mb_stride] = (dcv + 4) >> 3;
}
}
#if 1
@@ -1134,21 +1242,24 @@ void ff_er_frame_end(MpegEncContext *s){
guess_dc(s, s->dc_val[1], s->mb_width , s->mb_height , s->mb_stride, 0);
guess_dc(s, s->dc_val[2], s->mb_width , s->mb_height , s->mb_stride, 0);
#endif
+
/* filter luma DC */
- filter181(s->dc_val[0], s->mb_width*2, s->mb_height*2, s->b8_stride);
+ filter181(s->dc_val[0], s->mb_width * 2, s->mb_height * 2, s->b8_stride);
#if 1
/* render DC only intra */
- for(mb_y=0; mb_y<s->mb_height; mb_y++){
- for(mb_x=0; mb_x<s->mb_width; mb_x++){
+ for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
+ for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
uint8_t *dest_y, *dest_cb, *dest_cr;
- const int mb_xy= mb_x + mb_y * s->mb_stride;
+ const int mb_xy = mb_x + mb_y * s->mb_stride;
const int mb_type = s->current_picture.f.mb_type[mb_xy];
- error= s->error_status_table[mb_xy];
+ error = s->error_status_table[mb_xy];
- if(IS_INTER(mb_type)) continue;
- if(!(error&ER_AC_ERROR)) continue; //undamaged
+ if (IS_INTER(mb_type))
+ continue;
+ if (!(error & ER_AC_ERROR))
+ continue; // undamaged
dest_y = s->current_picture.f.data[0] + mb_x * 16 + mb_y * 16 * s->linesize;
dest_cb = s->current_picture.f.data[1] + mb_x * 8 + mb_y * 8 * s->uvlinesize;
@@ -1159,27 +1270,34 @@ void ff_er_frame_end(MpegEncContext *s){
}
#endif
- if(s->avctx->error_concealment&FF_EC_DEBLOCK){
+ if (s->avctx->error_concealment & FF_EC_DEBLOCK) {
/* filter horizontal block boundaries */
- h_block_filter(s, s->current_picture.f.data[0], s->mb_width*2, s->mb_height*2, s->linesize , 1);
- h_block_filter(s, s->current_picture.f.data[1], s->mb_width , s->mb_height , s->uvlinesize, 0);
- h_block_filter(s, s->current_picture.f.data[2], s->mb_width , s->mb_height , s->uvlinesize, 0);
+ h_block_filter(s, s->current_picture.f.data[0], s->mb_width * 2,
+ s->mb_height * 2, s->linesize, 1);
+ h_block_filter(s, s->current_picture.f.data[1], s->mb_width,
+ s->mb_height , s->uvlinesize, 0);
+ h_block_filter(s, s->current_picture.f.data[2], s->mb_width,
+ s->mb_height , s->uvlinesize, 0);
/* filter vertical block boundaries */
- v_block_filter(s, s->current_picture.f.data[0], s->mb_width*2, s->mb_height*2, s->linesize , 1);
- v_block_filter(s, s->current_picture.f.data[1], s->mb_width , s->mb_height , s->uvlinesize, 0);
- v_block_filter(s, s->current_picture.f.data[2], s->mb_width , s->mb_height , s->uvlinesize, 0);
+ v_block_filter(s, s->current_picture.f.data[0], s->mb_width * 2,
+ s->mb_height * 2, s->linesize, 1);
+ v_block_filter(s, s->current_picture.f.data[1], s->mb_width,
+ s->mb_height , s->uvlinesize, 0);
+ v_block_filter(s, s->current_picture.f.data[2], s->mb_width,
+ s->mb_height , s->uvlinesize, 0);
}
ec_clean:
/* clean a few tables */
- for(i=0; i<s->mb_num; i++){
- const int mb_xy= s->mb_index2xy[i];
- int error= s->error_status_table[mb_xy];
+ for (i = 0; i < s->mb_num; i++) {
+ const int mb_xy = s->mb_index2xy[i];
+ int error = s->error_status_table[mb_xy];
- if(s->pict_type!=AV_PICTURE_TYPE_B && (error&(ER_DC_ERROR|ER_MV_ERROR|ER_AC_ERROR))){
- s->mbskip_table[mb_xy]=0;
+ if (s->pict_type != AV_PICTURE_TYPE_B &&
+ (error & (ER_DC_ERROR | ER_MV_ERROR | ER_AC_ERROR))) {
+ s->mbskip_table[mb_xy] = 0;
}
- s->mbintra_table[mb_xy]=1;
+ s->mbintra_table[mb_xy] = 1;
}
}
diff --git a/libavformat/avformat.h b/libavformat/avformat.h
index 0dcaee5d6475f4797e54c46580a43586113235f1..0fbd33be5f9e46a47df1560725cca8a2a8942af2 100644
--- a/libavformat/avformat.h
+++ b/libavformat/avformat.h
@@ -1819,9 +1819,18 @@ int av_write_frame(AVFormatContext *s, AVPacket *pkt);
* demuxer level.
*
* @param s media file handle
- * @param pkt The packet, which contains the stream_index, buf/buf_size,
- dts/pts, ...
- * @return < 0 on error, = 0 if OK, 1 if end of stream wanted
+ * @param pkt The packet containing the data to be written. Libavformat takes
+ * ownership of the data and will free it when it sees fit using the packet's
+ * @ref AVPacket.destruct "destruct" field. The caller must not access the data
+ * after this function returns, as it may already be freed.
+ * Packet's @ref AVPacket.stream_index "stream_index" field must be set to the
+ * index of the corresponding stream in @ref AVFormatContext.streams
+ * "s.streams".
+ * It is very strongly recommended that timing information (@ref AVPacket.pts
+ * "pts", @ref AVPacket.dts "dts" @ref AVPacket.duration "duration") is set to
+ * correct values.
+ *
+ * @return 0 on success, a negative AVERROR on error.
*/
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt);
diff --git a/libavformat/mov.c b/libavformat/mov.c
index d2425961079079104af229b3d3fafdf2e7c2f8b3..3bb42fe3edb04d5b0bba5cca3ec001b4c3ab4ae0 100644
--- a/libavformat/mov.c
+++ b/libavformat/mov.c
@@ -602,12 +602,11 @@ static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom)
label_mask = 0;
for (i = 0; i < num_descr; i++) {
uint32_t label, cflags;
- float coords[3];
label = avio_rb32(pb); // mChannelLabel
cflags = avio_rb32(pb); // mChannelFlags
- AV_WN32(&coords[0], avio_rl32(pb)); // mCoordinates[0]
- AV_WN32(&coords[1], avio_rl32(pb)); // mCoordinates[1]
- AV_WN32(&coords[2], avio_rl32(pb)); // mCoordinates[2]
+ avio_rl32(pb); // mCoordinates[0]
+ avio_rl32(pb); // mCoordinates[1]
+ avio_rl32(pb); // mCoordinates[2]
if (layout_tag == 0) {
uint32_t mask_incr = ff_mov_get_channel_label(label);
if (mask_incr == 0) {
diff --git a/libavformat/utils.c b/libavformat/utils.c
index 7606a8eac8766c1ab2c92dca19c493993a82e3a9..9409ebe671215efecd9cf73c9a104e15514125c3 100644
--- a/libavformat/utils.c
+++ b/libavformat/utils.c
@@ -3492,9 +3492,12 @@ int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pk
* < 0 if an error occurred
*/
static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
- if(s->oformat->interleave_packet)
- return s->oformat->interleave_packet(s, out, in, flush);
- else
+ if (s->oformat->interleave_packet) {
+ int ret = s->oformat->interleave_packet(s, out, in, flush);
+ if (in)
+ av_free_packet(in);
+ return ret;
+ } else
return av_interleave_packet_per_dts(s, out, in, flush);
}
diff --git a/tests/audiogen.c b/tests/audiogen.c
index 493041f5d0718fea28138a7bd37b2d292f06e0fb..776fdf93164babcb22488d92066172b6b7415dad 100644
--- a/tests/audiogen.c
+++ b/tests/audiogen.c
@@ -48,23 +48,23 @@ static unsigned int myrnd(unsigned int *seed_ptr, int n)
/* integer cosinus */
static const unsigned short cos_table[(1 << COS_TABLE_BITS) + 2] = {
- 0x8000, 0x7ffe, 0x7ff6, 0x7fea, 0x7fd9, 0x7fc2, 0x7fa7, 0x7f87,
- 0x7f62, 0x7f38, 0x7f0a, 0x7ed6, 0x7e9d, 0x7e60, 0x7e1e, 0x7dd6,
- 0x7d8a, 0x7d3a, 0x7ce4, 0x7c89, 0x7c2a, 0x7bc6, 0x7b5d, 0x7aef,
- 0x7a7d, 0x7a06, 0x798a, 0x790a, 0x7885, 0x77fb, 0x776c, 0x76d9,
- 0x7642, 0x75a6, 0x7505, 0x7460, 0x73b6, 0x7308, 0x7255, 0x719e,
- 0x70e3, 0x7023, 0x6f5f, 0x6e97, 0x6dca, 0x6cf9, 0x6c24, 0x6b4b,
- 0x6a6e, 0x698c, 0x68a7, 0x67bd, 0x66d0, 0x65de, 0x64e9, 0x63ef,
- 0x62f2, 0x61f1, 0x60ec, 0x5fe4, 0x5ed7, 0x5dc8, 0x5cb4, 0x5b9d,
- 0x5a82, 0x5964, 0x5843, 0x571e, 0x55f6, 0x54ca, 0x539b, 0x5269,
- 0x5134, 0x4ffb, 0x4ec0, 0x4d81, 0x4c40, 0x4afb, 0x49b4, 0x486a,
- 0x471d, 0x45cd, 0x447b, 0x4326, 0x41ce, 0x4074, 0x3f17, 0x3db8,
- 0x3c57, 0x3af3, 0x398d, 0x3825, 0x36ba, 0x354e, 0x33df, 0x326e,
- 0x30fc, 0x2f87, 0x2e11, 0x2c99, 0x2b1f, 0x29a4, 0x2827, 0x26a8,
- 0x2528, 0x23a7, 0x2224, 0x209f, 0x1f1a, 0x1d93, 0x1c0c, 0x1a83,
- 0x18f9, 0x176e, 0x15e2, 0x1455, 0x12c8, 0x113a, 0x0fab, 0x0e1c,
- 0x0c8c, 0x0afb, 0x096b, 0x07d9, 0x0648, 0x04b6, 0x0324, 0x0192,
- 0x0000, 0x0000,
+ 0x8000, 0x7ffe, 0x7ff6, 0x7fea, 0x7fd9, 0x7fc2, 0x7fa7, 0x7f87,
+ 0x7f62, 0x7f38, 0x7f0a, 0x7ed6, 0x7e9d, 0x7e60, 0x7e1e, 0x7dd6,
+ 0x7d8a, 0x7d3a, 0x7ce4, 0x7c89, 0x7c2a, 0x7bc6, 0x7b5d, 0x7aef,
+ 0x7a7d, 0x7a06, 0x798a, 0x790a, 0x7885, 0x77fb, 0x776c, 0x76d9,
+ 0x7642, 0x75a6, 0x7505, 0x7460, 0x73b6, 0x7308, 0x7255, 0x719e,
+ 0x70e3, 0x7023, 0x6f5f, 0x6e97, 0x6dca, 0x6cf9, 0x6c24, 0x6b4b,
+ 0x6a6e, 0x698c, 0x68a7, 0x67bd, 0x66d0, 0x65de, 0x64e9, 0x63ef,
+ 0x62f2, 0x61f1, 0x60ec, 0x5fe4, 0x5ed7, 0x5dc8, 0x5cb4, 0x5b9d,
+ 0x5a82, 0x5964, 0x5843, 0x571e, 0x55f6, 0x54ca, 0x539b, 0x5269,
+ 0x5134, 0x4ffb, 0x4ec0, 0x4d81, 0x4c40, 0x4afb, 0x49b4, 0x486a,
+ 0x471d, 0x45cd, 0x447b, 0x4326, 0x41ce, 0x4074, 0x3f17, 0x3db8,
+ 0x3c57, 0x3af3, 0x398d, 0x3825, 0x36ba, 0x354e, 0x33df, 0x326e,
+ 0x30fc, 0x2f87, 0x2e11, 0x2c99, 0x2b1f, 0x29a4, 0x2827, 0x26a8,
+ 0x2528, 0x23a7, 0x2224, 0x209f, 0x1f1a, 0x1d93, 0x1c0c, 0x1a83,
+ 0x18f9, 0x176e, 0x15e2, 0x1455, 0x12c8, 0x113a, 0x0fab, 0x0e1c,
+ 0x0c8c, 0x0afb, 0x096b, 0x07d9, 0x0648, 0x04b6, 0x0324, 0x0192,
+ 0x0000, 0x0000,
};
#define CSHIFT (FRAC_BITS - COS_TABLE_BITS - 2)
@@ -80,7 +80,7 @@ static int int_cos(int a)
neg = 0;
if (a > (FRAC_ONE / 4)) {
neg = -1;
- a = (FRAC_ONE / 2) - a;
+ a = (FRAC_ONE / 2) - a;
}
p = cos_table + (a >> CSHIFT);
/* linear interpolation */
@@ -139,63 +139,63 @@ int main(int argc, char **argv)
/* 1 second of single freq sinus at 1000 Hz */
a = 0;
- for(i=0;i<1 * sample_rate;i++) {
+ for (i = 0; i < 1 * sample_rate; i++) {
v = (int_cos(a) * 10000) >> FRAC_BITS;
- for(j=0;j<nb_channels;j++)
+ for (j = 0; j < nb_channels; j++)
put_sample(v);
a += (1000 * FRAC_ONE) / sample_rate;
}
/* 1 second of varing frequency between 100 and 10000 Hz */
a = 0;
- for(i=0;i<1 * sample_rate;i++) {
+ for (i = 0; i < 1 * sample_rate; i++) {
v = (int_cos(a) * 10000) >> FRAC_BITS;
- for(j=0;j<nb_channels;j++)
+ for (j = 0; j < nb_channels; j++)
put_sample(v);
- f = 100 + (((10000 - 100) * i) / sample_rate);
+ f = 100 + (((10000 - 100) * i) / sample_rate);
a += (f * FRAC_ONE) / sample_rate;
}
/* 0.5 second of low amplitude white noise */
- for(i=0;i<sample_rate / 2;i++) {
+ for (i = 0; i < sample_rate / 2; i++) {
v = myrnd(&seed, 20000) - 10000;
- for(j=0;j<nb_channels;j++)
+ for (j = 0; j < nb_channels; j++)
put_sample(v);
}
/* 0.5 second of high amplitude white noise */
- for(i=0;i<sample_rate / 2;i++) {
+ for (i = 0; i < sample_rate / 2; i++) {
v = myrnd(&seed, 65535) - 32768;
- for(j=0;j<nb_channels;j++)
+ for (j = 0; j < nb_channels; j++)
put_sample(v);
}
/* 1 second of unrelated ramps for each channel */
- for(j=0;j<nb_channels;j++) {
- taba[j] = 0;
+ for (j = 0; j < nb_channels; j++) {
+ taba[j] = 0;
tabf1[j] = 100 + myrnd(&seed, 5000);
tabf2[j] = 100 + myrnd(&seed, 5000);
}
- for(i=0;i<1 * sample_rate;i++) {
- for(j=0;j<nb_channels;j++) {
+ for (i = 0; i < 1 * sample_rate; i++) {
+ for (j = 0; j < nb_channels; j++) {
v = (int_cos(taba[j]) * 10000) >> FRAC_BITS;
put_sample(v);
- f = tabf1[j] + (((tabf2[j] - tabf1[j]) * i) / sample_rate);
+ f = tabf1[j] + (((tabf2[j] - tabf1[j]) * i) / sample_rate);
taba[j] += (f * FRAC_ONE) / sample_rate;
}
}
/* 2 seconds of 500 Hz with varying volume */
- a = 0;
+ a = 0;
ampa = 0;
- for(i=0;i<2 * sample_rate;i++) {
- for(j=0;j<nb_channels;j++) {
+ for (i = 0; i < 2 * sample_rate; i++) {
+ for (j = 0; j < nb_channels; j++) {
amp = ((FRAC_ONE + int_cos(ampa)) * 5000) >> FRAC_BITS;
if (j & 1)
amp = 10000 - amp;
v = (int_cos(a) * amp) >> FRAC_BITS;
put_sample(v);
- a += (500 * FRAC_ONE) / sample_rate;
+ a += (500 * FRAC_ONE) / sample_rate;
ampa += (2 * FRAC_ONE) / sample_rate;
}
}
diff --git a/tests/base64.c b/tests/base64.c
index 75ba8bc5d2b199cf38bc8a72d2759bfdb4cf2523..5035ad96a77bc6b2bed5d4b2d532c40fcbe92e33 100644
--- a/tests/base64.c
+++ b/tests/base64.c
@@ -27,18 +27,19 @@ int main(void)
static const char b64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
unsigned i_bits = 0;
- int i_shift = 0;
- int out_len = 0;
+ int i_shift = 0;
+ int out_len = 0;
int in;
-#define putb64() do { \
+#define putb64() \
+ do { \
putchar(b64[(i_bits << 6 >> i_shift) & 0x3f]); \
out_len++; \
i_shift -= 6; \
} while (0)
while ((in = getchar()) != EOF) {
- i_bits = (i_bits << 8) + in;
+ i_bits = (i_bits << 8) + in;
i_shift += 8;
while (i_shift > 6)
putb64();
diff --git a/tests/rotozoom.c b/tests/rotozoom.c
index 1a4505729a4bf4cc4fb0f8d9c41c478c63172ddf..4406290de185f229bcefc2c00cbd0d5de67002d8 100644
--- a/tests/rotozoom.c
+++ b/tests/rotozoom.c
@@ -25,7 +25,7 @@
#include <inttypes.h>
#define FIXP (1 << 16)
-#define MY_PI 205887 //(M_PI * FIX)
+#define MY_PI 205887 // (M_PI * FIX)
static int64_t int_pow(int64_t a, int p)
{
@@ -47,7 +47,7 @@ static int64_t int_sin(int64_t a)
if (a >= MY_PI * 3 / 2)
a -= 2 * MY_PI; // -PI / 2 .. 3PI / 2
- if (a >= MY_PI /2)
+ if (a >= MY_PI / 2)
a = MY_PI - a; // -PI / 2 .. PI / 2
return a - int_pow(a, 3) / 6 + int_pow(a, 5) / 120 - int_pow(a, 7) / 5040;
@@ -67,49 +67,49 @@ static void rgb24_to_yuv420p(unsigned char *lum, unsigned char *cb,
wrap = width;
wrap3 = width * 3;
- p = src;
+ p = src;
for (y = 0; y < height; y += 2) {
for (x = 0; x < width; x += 2) {
- r = p[0];
- g = p[1];
- b = p[2];
- r1 = r;
- g1 = g;
- b1 = b;
- lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g +
- FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
- r = p[3];
- g = p[4];
- b = p[5];
- r1 += r;
- g1 += g;
- b1 += b;
- lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g +
- FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
- p += wrap3;
- lum += wrap;
-
- r = p[0];
- g = p[1];
- b = p[2];
- r1 += r;
- g1 += g;
- b1 += b;
- lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g +
- FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
- r = p[3];
- g = p[4];
- b = p[5];
- r1 += r;
- g1 += g;
- b1 += b;
- lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g +
- FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
-
- cb[0] = ((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +
- FIX(0.50000) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;
- cr[0] = ((FIX(0.50000) * r1 - FIX(0.41869) * g1 -
- FIX(0.08131) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;
+ r = p[0];
+ g = p[1];
+ b = p[2];
+ r1 = r;
+ g1 = g;
+ b1 = b;
+ lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g +
+ FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
+ r = p[3];
+ g = p[4];
+ b = p[5];
+ r1 += r;
+ g1 += g;
+ b1 += b;
+ lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g +
+ FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
+ p += wrap3;
+ lum += wrap;
+
+ r = p[0];
+ g = p[1];
+ b = p[2];
+ r1 += r;
+ g1 += g;
+ b1 += b;
+ lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g +
+ FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
+ r = p[3];
+ g = p[4];
+ b = p[5];
+ r1 += r;
+ g1 += g;
+ b1 += b;
+ lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g +
+ FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
+
+ cb[0] = ((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +
+ FIX(0.50000) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;
+ cr[0] = ((FIX(0.50000) * r1 - FIX(0.41869) * g1 -
+ FIX(0.08131) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;
cb++;
cr++;
@@ -171,7 +171,7 @@ static void put_pixel(int x, int y, int r, int g, int b)
y < 0 || y >= height)
return;
- p = rgb_tab + y * wrap + x * 3;
+ p = rgb_tab + y * wrap + x * 3;
p[0] = r;
p[1] = g;
p[2] = b;
@@ -181,8 +181,8 @@ unsigned char tab_r[256 * 256];
unsigned char tab_g[256 * 256];
unsigned char tab_b[256 * 256];
-int h_cos [360];
-int h_sin [360];
+int h_cos[360];
+int h_sin[360];
static int ipol(uint8_t *src, int x, int y)
{
@@ -202,8 +202,8 @@ static int ipol(uint8_t *src, int x, int y)
static void gen_image(int num, int w, int h)
{
- const int c = h_cos [num % 360];
- const int s = h_sin [num % 360];
+ const int c = h_cos[num % 360];
+ const int s = h_sin[num % 360];
const int xi = -(w / 2) * c;
const int yi = (w / 2) * s;
@@ -217,16 +217,19 @@ static void gen_image(int num, int w, int h)
int yprime = yj;
for (j = 0; j < h; j++) {
- x = xprime + xi + FIXP * w / 2;
+ x = xprime + xi + FIXP * w / 2;
xprime += s;
- y = yprime + yi + FIXP * h / 2;
+ y = yprime + yi + FIXP * h / 2;
yprime += c;
- for (i = 0; i < w; i++ ) {
+ for (i = 0; i < w; i++) {
x += c;
y -= s;
- put_pixel(i, j, ipol(tab_r, x, y), ipol(tab_g, x, y), ipol(tab_b, x, y));
+ put_pixel(i, j,
+ ipol(tab_r, x, y),
+ ipol(tab_g, x, y),
+ ipol(tab_b, x, y));
}
}
}
@@ -264,13 +267,13 @@ static int init_demo(const char *filename)
/* tables sin/cos */
for (i = 0; i < 360; i++) {
- radian = 2 * i * MY_PI / 360;
- h = 2 * FIXP + int_sin (radian);
+ radian = 2 * i * MY_PI / 360;
+ h = 2 * FIXP + int_sin(radian);
h_cos[i] = h * int_sin(radian + MY_PI / 2) / 2 / FIXP;
h_sin[i] = h * int_sin(radian) / 2 / FIXP;
}
- return 0;
+ return 0;
}
int main(int argc, char **argv)
diff --git a/tests/tiny_psnr.c b/tests/tiny_psnr.c
index 512d47bb8ea678907ae4758f8b2bb2a5835782d7..964b6ba75d4680f55a13e66daa520945f5bc19be 100644
--- a/tests/tiny_psnr.c
+++ b/tests/tiny_psnr.c
@@ -24,32 +24,32 @@
#include <inttypes.h>
#include <assert.h>
-#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
+#define FFMIN(a, b) ((a) > (b) ? (b) : (a))
#define F 100
#define SIZE 2048
-uint64_t exp16_table[21]={
- 65537,
- 65538,
- 65540,
- 65544,
- 65552,
- 65568,
- 65600,
- 65664,
- 65793,
- 66050,
- 66568,
- 67616,
- 69763,
- 74262,
- 84150,
- 108051,
- 178145,
- 484249,
- 3578144,
- 195360063,
- 582360139072LL,
+uint64_t exp16_table[21] = {
+ 65537,
+ 65538,
+ 65540,
+ 65544,
+ 65552,
+ 65568,
+ 65600,
+ 65664,
+ 65793,
+ 66050,
+ 66568,
+ 67616,
+ 69763,
+ 74262,
+ 84150,
+ 108051,
+ 178145,
+ 484249,
+ 3578144,
+ 195360063,
+ 582360139072LL,
};
#if 0
@@ -68,63 +68,66 @@ static unsigned int exp16(unsigned int a){
#endif
// 16.16 fixpoint log()
-static int64_t log16(uint64_t a){
+static int64_t log16(uint64_t a)
+{
int i;
- int out=0;
-
- if(a < 1<<16)
- return -log16((1LL<<32) / a);
- a<<=16;
-
- for(i=20;i>=0;i--){
- int64_t b= exp16_table[i];
- if(a<(b<<16)) continue;
- out |= 1<<i;
- a = ((a/b)<<16) + (((a%b)<<16) + b/2)/b;
+ int out = 0;
+
+ if (a < 1 << 16)
+ return -log16((1LL << 32) / a);
+ a <<= 16;
+
+ for (i = 20; i >= 0; i--) {
+ int64_t b = exp16_table[i];
+ if (a < (b << 16))
+ continue;
+ out |= 1 << i;
+ a = ((a / b) << 16) + (((a % b) << 16) + b / 2) / b;
}
return out;
}
static uint64_t int_sqrt(uint64_t a)
{
- uint64_t ret=0;
+ uint64_t ret = 0;
+ uint64_t ret_sq = 0;
int s;
- uint64_t ret_sq=0;
- for(s=31; s>=0; s--){
- uint64_t b= ret_sq + (1ULL<<(s*2)) + (ret<<s)*2;
- if(b<=a){
- ret_sq=b;
- ret+= 1ULL<<s;
+ for (s = 31; s >= 0; s--) {
+ uint64_t b = ret_sq + (1ULL << (s * 2)) + (ret << s) * 2;
+ if (b <= a) {
+ ret_sq = b;
+ ret += 1ULL << s;
}
}
return ret;
}
-int main(int argc,char* argv[]){
+int main(int argc, char *argv[])
+{
int i, j;
- uint64_t sse=0;
+ uint64_t sse = 0;
uint64_t dev;
FILE *f[2];
uint8_t buf[2][SIZE];
uint64_t psnr;
- int len= argc<4 ? 1 : atoi(argv[3]);
- int64_t max= (1<<(8*len))-1;
- int shift= argc<5 ? 0 : atoi(argv[4]);
- int skip_bytes = argc<6 ? 0 : atoi(argv[5]);
- int size0=0;
- int size1=0;
- int maxdist = 0;
-
- if(argc<3){
+ int len = argc < 4 ? 1 : atoi(argv[3]);
+ int64_t max = (1 << (8 * len)) - 1;
+ int shift = argc < 5 ? 0 : atoi(argv[4]);
+ int skip_bytes = argc < 6 ? 0 : atoi(argv[5]);
+ int size0 = 0;
+ int size1 = 0;
+ int maxdist = 0;
+
+ if (argc < 3) {
printf("tiny_psnr <file1> <file2> [<elem size> [<shift> [<skip bytes>]]]\n");
printf("WAV headers are skipped automatically.\n");
return 1;
}
- f[0]= fopen(argv[1], "rb");
- f[1]= fopen(argv[2], "rb");
- if(!f[0] || !f[1]){
+ f[0] = fopen(argv[1], "rb");
+ f[1] = fopen(argv[2], "rb");
+ if (!f[0] || !f[1]) {
fprintf(stderr, "Could not open input files.\n");
return 1;
}
@@ -133,12 +136,12 @@ int main(int argc,char* argv[]){
uint8_t *p = buf[i];
if (fread(p, 1, 12, f[i]) != 12)
return 1;
- if (!memcmp(p, "RIFF", 4) &&
- !memcmp(p+8, "WAVE", 4)) {
+ if (!memcmp(p, "RIFF", 4) &&
+ !memcmp(p + 8, "WAVE", 4)) {
if (fread(p, 1, 8, f[i]) != 8)
return 1;
while (memcmp(p, "data", 4)) {
- int s = p[4] | p[5]<<8 | p[6]<<16 | p[7]<<24;
+ int s = p[4] | p[5] << 8 | p[6] << 16 | p[7] << 24;
fseek(f[i], s, SEEK_CUR);
if (fread(p, 1, 8, f[i]) != 8)
return 1;
@@ -148,47 +151,47 @@ int main(int argc,char* argv[]){
}
}
- fseek(f[shift<0], abs(shift), SEEK_CUR);
+ fseek(f[shift < 0], abs(shift), SEEK_CUR);
- fseek(f[0],skip_bytes,SEEK_CUR);
- fseek(f[1],skip_bytes,SEEK_CUR);
+ fseek(f[0], skip_bytes, SEEK_CUR);
+ fseek(f[1], skip_bytes, SEEK_CUR);
- for(;;){
- int s0= fread(buf[0], 1, SIZE, f[0]);
- int s1= fread(buf[1], 1, SIZE, f[1]);
+ for (;;) {
+ int s0 = fread(buf[0], 1, SIZE, f[0]);
+ int s1 = fread(buf[1], 1, SIZE, f[1]);
- for(j=0; j<FFMIN(s0,s1); j++){
- int64_t a= buf[0][j];
- int64_t b= buf[1][j];
+ for (j = 0; j < FFMIN(s0, s1); j++) {
+ int64_t a = buf[0][j];
+ int64_t b = buf[1][j];
int dist;
- if(len==2){
- a= (int16_t)(a | (buf[0][++j]<<8));
- b= (int16_t)(b | (buf[1][ j]<<8));
+ if (len == 2) {
+ a = (int16_t)(a | (buf[0][++j] << 8));
+ b = (int16_t)(b | (buf[1][ j] << 8));
}
- sse += (a-b) * (a-b);
- dist = abs(a-b);
- if (dist > maxdist) maxdist = dist;
+ sse += (a - b) * (a - b);
+ dist = abs(a - b);
+ if (dist > maxdist)
+ maxdist = dist;
}
size0 += s0;
size1 += s1;
- if(s0+s1<=0)
+ if (s0 + s1 <= 0)
break;
}
- i= FFMIN(size0,size1)/len;
- if(!i) i=1;
- dev= int_sqrt( ((sse/i)*F*F) + (((sse%i)*F*F) + i/2)/i );
- if(sse)
- psnr= ((2*log16(max<<16) + log16(i) - log16(sse))*284619LL*F + (1LL<<31)) / (1LL<<32);
+ i = FFMIN(size0, size1) / len;
+ if (!i)
+ i = 1;
+ dev = int_sqrt(((sse / i) * F * F) + (((sse % i) * F * F) + i / 2) / i);
+ if (sse)
+ psnr = ((2 * log16(max << 16) + log16(i) - log16(sse)) *
+ 284619LL * F + (1LL << 31)) / (1LL << 32);
else
- psnr= 1000*F-1; //floating point free infinity :)
+ psnr = 1000 * F - 1; // floating point free infinity :)
printf("stddev:%5d.%02d PSNR:%3d.%02d MAXDIFF:%5d bytes:%9d/%9d\n",
- (int)(dev/F), (int)(dev%F),
- (int)(psnr/F), (int)(psnr%F),
- maxdist,
- size0, size1);
+ (int)(dev / F), (int)(dev % F),
+ (int)(psnr / F), (int)(psnr % F),
+ maxdist, size0, size1);
return 0;
}
-
-
diff --git a/tests/videogen.c b/tests/videogen.c
index bdd5a806ff6c7e8373e8a22efe23949e54f2cc15..bdd8c8e204a24e60e8a344ee625e44ef2b9b3785 100644
--- a/tests/videogen.c
+++ b/tests/videogen.c
@@ -27,67 +27,73 @@
#define SCALEBITS 8
#define ONE_HALF (1 << (SCALEBITS - 1))
-#define FIX(x) ((int) ((x) * (1L<<SCALEBITS) + 0.5))
+#define FIX(x) ((int) ((x) * (1L << SCALEBITS) + 0.5))
static void rgb24_to_yuv420p(uint8_t *lum, uint8_t *cb, uint8_t *cr,
- uint8_t *src, int width, int height)
+ uint8_t *src, int width, int height)
{
int wrap, wrap3, x, y;
int r, g, b, r1, g1, b1;
uint8_t *p;
- wrap = width;
+ wrap = width;
wrap3 = width * 3;
- p = src;
- for(y=0;y<height;y+=2) {
- for(x=0;x<width;x+=2) {
- r = p[0];
- g = p[1];
- b = p[2];
- r1 = r;
- g1 = g;
- b1 = b;
- lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g +
- FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
- r = p[3];
- g = p[4];
- b = p[5];
- r1 += r;
- g1 += g;
- b1 += b;
- lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g +
- FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
- p += wrap3;
- lum += wrap;
-
- r = p[0];
- g = p[1];
- b = p[2];
- r1 += r;
- g1 += g;
- b1 += b;
- lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g +
- FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
- r = p[3];
- g = p[4];
- b = p[5];
- r1 += r;
- g1 += g;
- b1 += b;
- lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g +
- FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
-
- cb[0] = ((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +
- FIX(0.50000) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;
- cr[0] = ((FIX(0.50000) * r1 - FIX(0.41869) * g1 -
- FIX(0.08131) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;
+ p = src;
+ for (y = 0; y < height; y += 2) {
+ for (x = 0; x < width; x += 2) {
+ r = p[0];
+ g = p[1];
+ b = p[2];
+ r1 = r;
+ g1 = g;
+ b1 = b;
+ lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g +
+ FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
+ r = p[3];
+ g = p[4];
+ b = p[5];
+ r1 += r;
+ g1 += g;
+ b1 += b;
+ lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g +
+ FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
+ p += wrap3;
+ lum += wrap;
+
+ r = p[0];
+ g = p[1];
+ b = p[2];
+ r1 += r;
+ g1 += g;
+ b1 += b;
+ lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g +
+ FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
+ r = p[3];
+ g = p[4];
+ b = p[5];
+ r1 += r;
+ g1 += g;
+ b1 += b;
+ lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g +
+ FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
+
+ cb[0] = 128 + ((- FIX(0.16874) * r1 -
+ FIX(0.33126) * g1 +
+ FIX(0.50000) * b1 +
+ 4 * ONE_HALF - 1)
+ >> (SCALEBITS + 2));
+ cr[0] = 128 + ((FIX(0.50000) * r1 -
+ FIX(0.41869) * g1 -
+ FIX(0.08131) * b1 +
+ 4 * ONE_HALF - 1)
+ >> (SCALEBITS + 2));
cb++;
cr++;
- p += -wrap3 + 2 * 3;
+ p += -wrap3 + 2 * 3;
lum += -wrap + 2;
}
- p += wrap3;
+ p += wrap3;
lum += wrap;
}
}
@@ -106,19 +112,19 @@ static void pgmyuv_save(const char *filename, int w, int h,
unsigned char *lum_tab, *cb_tab, *cr_tab;
lum_tab = malloc(w * h);
- cb_tab = malloc((w * h) / 4);
- cr_tab = malloc((w * h) / 4);
+ cb_tab = malloc((w * h) / 4);
+ cr_tab = malloc((w * h) / 4);
rgb24_to_yuv420p(lum_tab, cb_tab, cr_tab, rgb_tab, w, h);
- f = fopen(filename,"wb");
+ f = fopen(filename, "wb");
fprintf(f, "P5\n%d %d\n%d\n", w, (h * 3) / 2, 255);
fwrite(lum_tab, 1, w * h, f);
h2 = h / 2;
w2 = w / 2;
cb = cb_tab;
cr = cr_tab;
- for(i=0;i<h2;i++) {
+ for (i = 0; i < h2; i++) {
fwrite(cb, 1, w2, f);
fwrite(cr, 1, w2, f);
cb += w2;
@@ -142,7 +148,7 @@ static void put_pixel(int x, int y, int r, int g, int b)
y < 0 || y >= height)
return;
- p = rgb_tab + y * wrap + x * 3;
+ p = rgb_tab + y * wrap + x * 3;
p[0] = r;
p[1] = g;
p[2] = b;
@@ -180,7 +186,7 @@ static int int_cos(int a)
neg = 0;
if (a > (FRAC_ONE / 4)) {
neg = -1;
- a = (FRAC_ONE / 2) - a;
+ a = (FRAC_ONE / 2) - a;
}
v = FRAC_ONE - ((a * a) >> 4);
v = (v ^ neg) - neg;
@@ -204,7 +210,7 @@ static void gen_image(int num, int w, int h)
unsigned int seed1;
if (num == 0) {
- for(i=0;i<NB_OBJS;i++) {
+ for (i = 0; i < NB_OBJS; i++) {
objs[i].x = myrnd(&seed, w);
objs[i].y = myrnd(&seed, h);
objs[i].w = myrnd(&seed, w / 4) + 10;
@@ -219,21 +225,21 @@ static void gen_image(int num, int w, int h)
/* test motion estimation */
dx = int_cos(num * FRAC_ONE / 50) * 35;
dy = int_cos(num * FRAC_ONE / 50 + FRAC_ONE / 10) * 30;
- for(y=0;y<h;y++) {
- for(x=0;x<w;x++) {
+ for (y = 0; y < h; y++) {
+ for (x = 0; x < w; x++) {
x1 = (x << FRAC_BITS) + dx;
y1 = (y << FRAC_BITS) + dy;
- r = ((y1 * 7) >> FRAC_BITS) & 0xff;
- g = (((x1 + y1) * 9) >> FRAC_BITS) & 0xff;
- b = ((x1 * 5) >> FRAC_BITS) & 0xff;
+ r = ((y1 * 7) >> FRAC_BITS) & 0xff;
+ g = (((x1 + y1) * 9) >> FRAC_BITS) & 0xff;
+ b = ((x1 * 5) >> FRAC_BITS) & 0xff;
put_pixel(x, y, r, g, b);
}
}
/* then some noise with very high intensity to test saturation */
seed1 = num;
- for(y=0;y<NOISE_W;y++) {
- for(x=0;x<NOISE_W;x++) {
+ for (y = 0; y < NOISE_W; y++) {
+ for (x = 0; x < NOISE_W; x++) {
r = myrnd(&seed1, 256);
g = myrnd(&seed1, 256);
b = myrnd(&seed1, 256);
@@ -242,11 +248,11 @@ static void gen_image(int num, int w, int h)
}
/* then moving objects */
- for(i=0;i<NB_OBJS;i++) {
+ for (i = 0; i < NB_OBJS; i++) {
VObj *p = &objs[i];
seed1 = i;
- for(y=0;y<p->h;y++) {
- for(x=0;x<p->w;x++) {
+ for (y = 0; y < p->h; y++) {
+ for (x = 0; x < p->w; x++) {
r = p->r;
g = p->g;
b = p->b;
@@ -277,11 +283,11 @@ int main(int argc, char **argv)
h = DEFAULT_HEIGHT;
rgb_tab = malloc(w * h * 3);
- wrap = w * 3;
- width = w;
- height = h;
+ wrap = w * 3;
+ width = w;
+ height = h;
- for(i=0;i<DEFAULT_NB_PICT;i++) {
+ for (i = 0; i < DEFAULT_NB_PICT; i++) {
snprintf(buf, sizeof(buf), "%s%02d.pgm", argv[1], i);
gen_image(i, w, h);
pgmyuv_save(buf, w, h, rgb_tab);