FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/msmpeg4.c	Lines:	100	145	69.0 %
Date:	2020-09-21 17:35:45	Branches:	41	71	57.7 %


/*
 * MSMPEG4 backend for encoder and decoder
 * Copyright (c) 2001 Fabrice Bellard
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
 *
 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * MSMPEG4 backend for encoder and decoder
 */

#include "avcodec.h"
#include "idctdsp.h"
#include "mpegvideo.h"
#include "msmpeg4.h"
#include "libavutil/x86/asm.h"
#include "h263.h"
#include "mpeg4video.h"
#include "msmpeg4data.h"
#include "mpegvideodata.h"
#include "vc1data.h"
#include "libavutil/imgutils.h"

/*
 * You can also call this codec: MPEG-4 with a twist!
 *
 * TODO:
 *        - (encoding) select best mv table (two choices)
 *        - (encoding) select best vlc/dc table
 */

/* This table is practically identical to the one from H.263
 * except that it is inverted. */
static av_cold void init_h263_dc_for_msmpeg4(void)
{
        int level, uni_code, uni_len;

        if(ff_v2_dc_chroma_table[255 + 256][1])
            return;

        for(level=-256; level<256; level++){
            int size, v, l;
            /* find number of bits */
            size = 0;
            v = abs(level);
            while (v) {
                v >>= 1;
                    size++;
            }

            if (level < 0)
                l= (-level) ^ ((1 << size) - 1);
            else
                l= level;

            /* luminance H.263 */
            uni_code= ff_mpeg4_DCtab_lum[size][0];
            uni_len = ff_mpeg4_DCtab_lum[size][1];
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility

            if (size > 0) {
                uni_code<<=size; uni_code|=l;
                uni_len+=size;
                if (size > 8){
                    uni_code<<=1; uni_code|=1;
                    uni_len++;
                }
            }
            ff_v2_dc_lum_table[level + 256][0] = uni_code;
            ff_v2_dc_lum_table[level + 256][1] = uni_len;

            /* chrominance H.263 */
            uni_code= ff_mpeg4_DCtab_chrom[size][0];
            uni_len = ff_mpeg4_DCtab_chrom[size][1];
            uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility

            if (size > 0) {
                uni_code<<=size; uni_code|=l;
                uni_len+=size;
                if (size > 8){
                    uni_code<<=1; uni_code|=1;
                    uni_len++;
                }
            }
            ff_v2_dc_chroma_table[level + 256][0] = uni_code;
            ff_v2_dc_chroma_table[level + 256][1] = uni_len;

        }
}

av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
{
    switch(s->msmpeg4_version){
    case 1:
    case 2:
        s->y_dc_scale_table=
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
        break;
    case 3:
        if(s->workaround_bugs){
            s->y_dc_scale_table= ff_old_ff_y_dc_scale_table;
            s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
        } else{
            s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
            s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
        }
        break;
    case 4:
    case 5:
        s->y_dc_scale_table= ff_wmv1_y_dc_scale_table;
        s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
        break;
#if CONFIG_VC1_DECODER
    case 6:
        s->y_dc_scale_table= ff_wmv3_dc_scale_table;
        s->c_dc_scale_table= ff_wmv3_dc_scale_table;
        break;
#endif

    }


    if(s->msmpeg4_version>=4){
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,   ff_wmv1_scantable[1]);
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_wmv1_scantable[2]);
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_wmv1_scantable[3]);
        ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable,   ff_wmv1_scantable[0]);
    }
    //Note the default tables are set in common_init in mpegvideo.c

    init_h263_dc_for_msmpeg4();
}

/* predict coded block */
int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
{
    int xy, wrap, pred, a, b, c;

    xy = s->block_index[n];
    wrap = s->b8_stride;

    /* B C
     * A X
     */
    a = s->coded_block[xy - 1       ];
    b = s->coded_block[xy - 1 - wrap];
    c = s->coded_block[xy     - wrap];

    if (b == c) {
        pred = a;
    } else {
        pred = c;
    }

    /* store value */
    *coded_block_ptr = &s->coded_block[xy];

    return pred;
}

static int get_dc(uint8_t *src, int stride, int scale, int block_size)
{
    int y;
    int sum=0;
    for(y=0; y<block_size; y++){
        int x;
        for(x=0; x<block_size; x++){
            sum+=src[x + y*stride];
        }
    }
    return FASTDIV((sum + (scale>>1)), scale);
}

/* dir = 0: left, dir = 1: top prediction */
int ff_msmpeg4_pred_dc(MpegEncContext *s, int n,
                       int16_t **dc_val_ptr, int *dir_ptr)
{
    int a, b, c, wrap, pred, scale;
    int16_t *dc_val;

    /* find prediction */
    if (n < 4) {
        scale = s->y_dc_scale;
    } else {
        scale = s->c_dc_scale;
    }

    wrap = s->block_wrap[n];
    dc_val= s->dc_val[0] + s->block_index[n];

    /* B C
     * A X
     */
    a = dc_val[ - 1];
    b = dc_val[ - 1 - wrap];
    c = dc_val[ - wrap];

    if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
        b=c=1024;
    }

    /* XXX: the following solution consumes divisions, but it does not
       necessitate to modify mpegvideo.c. The problem comes from the
       fact they decided to store the quantized DC (which would lead
       to problems if Q could vary !) */
#if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
    __asm__ volatile(
        "movl %3, %%eax         \n\t"
        "shrl $1, %%eax         \n\t"
        "addl %%eax, %2         \n\t"
        "addl %%eax, %1         \n\t"
        "addl %0, %%eax         \n\t"
        "imull %4               \n\t"
        "movl %%edx, %0         \n\t"
        "movl %1, %%eax         \n\t"
        "imull %4               \n\t"
        "movl %%edx, %1         \n\t"
        "movl %2, %%eax         \n\t"
        "imull %4               \n\t"
        "movl %%edx, %2         \n\t"
        : "+b" (a), "+c" (b), "+D" (c)
        : "g" (scale), "S" (ff_inverse[scale])
        : "%eax", "%edx"
    );
#else
    /* Divisions are costly everywhere; optimize the most common case. */
    if (scale == 8) {
        a = (a + (8 >> 1)) / 8;
        b = (b + (8 >> 1)) / 8;
        c = (c + (8 >> 1)) / 8;
    } else {
        a = FASTDIV((a + (scale >> 1)), scale);
        b = FASTDIV((b + (scale >> 1)), scale);
        c = FASTDIV((c + (scale >> 1)), scale);
    }
#endif
    /* XXX: WARNING: they did not choose the same test as MPEG-4. This
       is very important ! */
    if(s->msmpeg4_version>3){
        if(s->inter_intra_pred){
            uint8_t *dest;
            int wrap;

            if(n==1){
                pred=a;
                *dir_ptr = 0;
            }else if(n==2){
                pred=c;
                *dir_ptr = 1;
            }else if(n==3){
                if (abs(a - b) < abs(b - c)) {
                    pred = c;
                    *dir_ptr = 1;
                } else {
                    pred = a;
                    *dir_ptr = 0;
                }
            }else{
                int bs = 8 >> s->avctx->lowres;
                if(n<4){
                    wrap= s->linesize;
                    dest= s->current_picture.f->data[0] + (((n >> 1) + 2*s->mb_y) * bs*  wrap ) + ((n & 1) + 2*s->mb_x) * bs;
                }else{
                    wrap= s->uvlinesize;
                    dest= s->current_picture.f->data[n - 3] + (s->mb_y * bs * wrap) + s->mb_x * bs;
                }
                if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
                else           a= get_dc(dest-bs, wrap, scale*8>>(2*s->avctx->lowres), bs);
                if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
                else           c= get_dc(dest-bs*wrap, wrap, scale*8>>(2*s->avctx->lowres), bs);

                if (s->h263_aic_dir==0) {
                    pred= a;
                    *dir_ptr = 0;
                }else if (s->h263_aic_dir==1) {
                    if(n==0){
                        pred= c;
                        *dir_ptr = 1;
                    }else{
                        pred= a;
                        *dir_ptr = 0;
                    }
                }else if (s->h263_aic_dir==2) {
                    if(n==0){
                        pred= a;
                        *dir_ptr = 0;
                    }else{
                        pred= c;
                        *dir_ptr = 1;
                    }
                } else {
                    pred= c;
                    *dir_ptr = 1;
                }
            }
        }else{
            if (abs(a - b) < abs(b - c)) {
                pred = c;
                *dir_ptr = 1;
            } else {
                pred = a;
                *dir_ptr = 0;
            }
        }
    }else{
        if (abs(a - b) <= abs(b - c)) {
            pred = c;
            *dir_ptr = 1;
        } else {
            pred = a;
            *dir_ptr = 0;
        }
    }

    /* update predictor */
    *dc_val_ptr = &dc_val[0];
    return pred;
}



Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* MSMPEG4 backend for encoder and decoder
3			* Copyright (c) 2001 Fabrice Bellard
4			* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5			*
6			* msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
7			*
8			* This file is part of FFmpeg.
9			*
10			* FFmpeg is free software; you can redistribute it and/or
11			* modify it under the terms of the GNU Lesser General Public
12			* License as published by the Free Software Foundation; either
13			* version 2.1 of the License, or (at your option) any later version.
14			*
15			* FFmpeg is distributed in the hope that it will be useful,
16			* but WITHOUT ANY WARRANTY; without even the implied warranty of
17			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18			* Lesser General Public License for more details.
19			*
20			* You should have received a copy of the GNU Lesser General Public
21			* License along with FFmpeg; if not, write to the Free Software
22			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23			*/
24
25			/**
26			* @file
27			* MSMPEG4 backend for encoder and decoder
28			*/
29
30			#include "avcodec.h"
31			#include "idctdsp.h"
32			#include "mpegvideo.h"
33			#include "msmpeg4.h"
34			#include "libavutil/x86/asm.h"
35			#include "h263.h"
36			#include "mpeg4video.h"
37			#include "msmpeg4data.h"
38			#include "mpegvideodata.h"
39			#include "vc1data.h"
40			#include "libavutil/imgutils.h"
41
42			/*
43			* You can also call this codec: MPEG-4 with a twist!
44			*
45			* TODO:
46			* - (encoding) select best mv table (two choices)
47			* - (encoding) select best vlc/dc table
48			*/
49
50			/* This table is practically identical to the one from H.263
51			* except that it is inverted. */
52		104	static av_cold void init_h263_dc_for_msmpeg4(void)
53			{
54			int level, uni_code, uni_len;
55
56	✓✓	104	if(ff_v2_dc_chroma_table[255 + 256][1])
57		44	return;
58
59	✓✓	30780	for(level=-256; level<256; level++){
60			int size, v, l;
61			/* find number of bits */
62		30720	size = 0;
63		30720	v = abs(level);
64	✓✓	246420	while (v) {
65		215700	v >>= 1;
66		215700	size++;
67			}
68
69	✓✓	30720	if (level < 0)
70		15360	l= (-level) ^ ((1 << size) - 1);
71			else
72		15360	l= level;
73
74			/* luminance H.263 */
75		30720	uni_code= ff_mpeg4_DCtab_lum[size][0];
76		30720	uni_len = ff_mpeg4_DCtab_lum[size][1];
77		30720	uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
78
79	✓✓	30720	if (size > 0) {
80		30660	uni_code<<=size; uni_code\|=l;
81		30660	uni_len+=size;
82	✓✓	30660	if (size > 8){
83		60	uni_code<<=1; uni_code\|=1;
84		60	uni_len++;
85			}
86			}
87		30720	ff_v2_dc_lum_table[level + 256][0] = uni_code;
88		30720	ff_v2_dc_lum_table[level + 256][1] = uni_len;
89
90			/* chrominance H.263 */
91		30720	uni_code= ff_mpeg4_DCtab_chrom[size][0];
92		30720	uni_len = ff_mpeg4_DCtab_chrom[size][1];
93		30720	uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
94
95	✓✓	30720	if (size > 0) {
96		30660	uni_code<<=size; uni_code\|=l;
97		30660	uni_len+=size;
98	✓✓	30660	if (size > 8){
99		60	uni_code<<=1; uni_code\|=1;
100		60	uni_len++;
101			}
102			}
103		30720	ff_v2_dc_chroma_table[level + 256][0] = uni_code;
104		30720	ff_v2_dc_chroma_table[level + 256][1] = uni_len;
105
106			}
107			}
108
109		104	av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
110			{
111	✓✓✓✓ ✗	104	switch(s->msmpeg4_version){
112		15	case 1:
113			case 2:
114		15	s->y_dc_scale_table=
115		15	s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
116		15	break;
117		18	case 3:
118	✓✓	18	if(s->workaround_bugs){
119		13	s->y_dc_scale_table= ff_old_ff_y_dc_scale_table;
120		13	s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
121			} else{
122		5	s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
123		5	s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
124			}
125		18	break;
126		29	case 4:
127			case 5:
128		29	s->y_dc_scale_table= ff_wmv1_y_dc_scale_table;
129		29	s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
130		29	break;
131			#if CONFIG_VC1_DECODER
132		42	case 6:
133		42	s->y_dc_scale_table= ff_wmv3_dc_scale_table;
134		42	s->c_dc_scale_table= ff_wmv3_dc_scale_table;
135		42	break;
136			#endif
137
138			}
139
140
141	✓✓	104	if(s->msmpeg4_version>=4){
142		71	ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_wmv1_scantable[1]);
143		71	ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_wmv1_scantable[2]);
144		71	ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_wmv1_scantable[3]);
145		71	ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_wmv1_scantable[0]);
146			}
147			//Note the default tables are set in common_init in mpegvideo.c
148
149		104	init_h263_dc_for_msmpeg4();
150		104	}
151
152			/* predict coded block */
153		222472	int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
154			{
155			int xy, wrap, pred, a, b, c;
156
157		222472	xy = s->block_index[n];
158		222472	wrap = s->b8_stride;
159
160			/* B C
161			* A X
162			*/
163		222472	a = s->coded_block[xy - 1 ];
164		222472	b = s->coded_block[xy - 1 - wrap];
165		222472	c = s->coded_block[xy - wrap];
166
167	✓✓	222472	if (b == c) {
168		194858	pred = a;
169			} else {
170		27614	pred = c;
171			}
172
173			/* store value */
174		222472	*coded_block_ptr = &s->coded_block[xy];
175
176		222472	return pred;
177			}
178
179			static int get_dc(uint8_t *src, int stride, int scale, int block_size)
180			{
181			int y;
182			int sum=0;
183			for(y=0; y<block_size; y++){
184			int x;
185			for(x=0; x<block_size; x++){
186			sum+=src[x + y*stride];
187			}
188			}
189			return FASTDIV((sum + (scale>>1)), scale);
190			}
191
192			/* dir = 0: left, dir = 1: top prediction */
193		433272	int ff_msmpeg4_pred_dc(MpegEncContext *s, int n,
194			int16_t *dc_val_ptr, int dir_ptr)
195			{
196			int a, b, c, wrap, pred, scale;
197			int16_t *dc_val;
198
199			/* find prediction */
200	✓✓	433272	if (n < 4) {
201		288848	scale = s->y_dc_scale;
202			} else {
203		144424	scale = s->c_dc_scale;
204			}
205
206		433272	wrap = s->block_wrap[n];
207		433272	dc_val= s->dc_val[0] + s->block_index[n];
208
209			/* B C
210			* A X
211			*/
212		433272	a = dc_val[ - 1];
213		433272	b = dc_val[ - 1 - wrap];
214		433272	c = dc_val[ - wrap];
215
216	✓✓✓✓ ✓✓	433272	if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
217		6624	b=c=1024;
218			}
219
220			/* XXX: the following solution consumes divisions, but it does not
221			necessitate to modify mpegvideo.c. The problem comes from the
222			fact they decided to store the quantized DC (which would lead
223			to problems if Q could vary !) */
224			#if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
225		433272	__asm__ volatile(
226			"movl %3, %%eax \n\t"
227			"shrl $1, %%eax \n\t"
228			"addl %%eax, %2 \n\t"
229			"addl %%eax, %1 \n\t"
230			"addl %0, %%eax \n\t"
231			"imull %4 \n\t"
232			"movl %%edx, %0 \n\t"
233			"movl %1, %%eax \n\t"
234			"imull %4 \n\t"
235			"movl %%edx, %1 \n\t"
236			"movl %2, %%eax \n\t"
237			"imull %4 \n\t"
238			"movl %%edx, %2 \n\t"
239			: "+b" (a), "+c" (b), "+D" (c)
240		433272	: "g" (scale), "S" (ff_inverse[scale])
241			: "%eax", "%edx"
242			);
243			#else
244			/* Divisions are costly everywhere; optimize the most common case. */
245			if (scale == 8) {
246			a = (a + (8 >> 1)) / 8;
247			b = (b + (8 >> 1)) / 8;
248			c = (c + (8 >> 1)) / 8;
249			} else {
250			a = FASTDIV((a + (scale >> 1)), scale);
251			b = FASTDIV((b + (scale >> 1)), scale);
252			c = FASTDIV((c + (scale >> 1)), scale);
253			}
254			#endif
255			/* XXX: WARNING: they did not choose the same test as MPEG-4. This
256			is very important ! */
257	✓✓	433272	if(s->msmpeg4_version>3){
258	✗✓	212484	if(s->inter_intra_pred){
259			uint8_t *dest;
260			int wrap;
261
262			if(n==1){
263			pred=a;
264			*dir_ptr = 0;
265			}else if(n==2){
266			pred=c;
267			*dir_ptr = 1;
268			}else if(n==3){
269			if (abs(a - b) < abs(b - c)) {
270			pred = c;
271			*dir_ptr = 1;
272			} else {
273			pred = a;
274			*dir_ptr = 0;
275			}
276			}else{
277			int bs = 8 >> s->avctx->lowres;
278			if(n<4){
279			wrap= s->linesize;
280			dest= s->current_picture.f->data[0] + (((n >> 1) + 2s->mb_y) bs* wrap ) + ((n & 1) + 2s->mb_x) bs;
281			}else{
282			wrap= s->uvlinesize;
283			dest= s->current_picture.f->data[n - 3] + (s->mb_y * bs * wrap) + s->mb_x * bs;
284			}
285			if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
286			else a= get_dc(dest-bs, wrap, scale8>>(2s->avctx->lowres), bs);
287			if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
288			else c= get_dc(dest-bswrap, wrap, scale8>>(2*s->avctx->lowres), bs);
289
290			if (s->h263_aic_dir==0) {
291			pred= a;
292			*dir_ptr = 0;
293			}else if (s->h263_aic_dir==1) {
294			if(n==0){
295			pred= c;
296			*dir_ptr = 1;
297			}else{
298			pred= a;
299			*dir_ptr = 0;
300			}
301			}else if (s->h263_aic_dir==2) {
302			if(n==0){
303			pred= a;
304			*dir_ptr = 0;
305			}else{
306			pred= c;
307			*dir_ptr = 1;
308			}
309			} else {
310			pred= c;
311			*dir_ptr = 1;
312			}
313			}
314			}else{
315	✓✓	212484	if (abs(a - b) < abs(b - c)) {
316		86305	pred = c;
317		86305	*dir_ptr = 1;
318			} else {
319		126179	pred = a;
320		126179	*dir_ptr = 0;
321			}
322			}
323			}else{
324	✓✓	220788	if (abs(a - b) <= abs(b - c)) {
325		116422	pred = c;
326		116422	*dir_ptr = 1;
327			} else {
328		104366	pred = a;
329		104366	*dir_ptr = 0;
330			}
331			}
332
333			/* update predictor */
334		433272	*dc_val_ptr = &dc_val[0];
335		433272	return pred;
336			}
337