腰痛吃什么药好| 做梦梦见死去的亲人是什么意思| 盆腔积液有什么症状有哪些| 王字旁一个玉读什么| 排卵期一般是什么时候| 糖醋鱼用什么鱼做好吃| av是什么意思| 凌志和雷克萨斯有什么区别| 肾疼是因为什么| 百香果什么时候吃最好| 不疼不痒的红疹是什么| 药师是干什么的| 胃经常胀气是什么原因| allin什么意思| 6月22日什么星座| 侍中是什么官| 肌酐是什么指标| 二月二十二日是什么星座| 路由器坏了有什么症状| 结膜炎用什么药| 吃什么皮肤白的最快| 为什么家里会有隐翅虫| 心脏增大吃什么药| 轻度强化是什么意思| 血压高会有什么症状| 放血有什么好处| 元字五行属什么| 心肝火旺吃什么中成药| 肿瘤和囊肿有什么区别| 对什么有益英语| 什么是盗汗症状| 甲钴胺的副作用是什么| 更年期吃什么药| 卵巢多囊是什么意思| 急性扁桃体炎什么原因导致的| 突然高血压是什么原因引起的| 饱和脂肪酸是什么| 人为什么会低血糖| 喝什么美白| ns是什么| 世界屋脊指的是什么| 老鼠疮是什么病| 取环后要注意什么事项| 社恐的人适合什么工作| 六月二号什么星座| 为什么叫书记| 肌酐高是什么意思| 火龙果什么季节成熟| 张学友和张家辉什么关系| 中药不能和什么一起吃| 斩衰是什么意思| 条件致病菌是什么意思| 为什么会打雷| 咳嗽应该挂什么科| 1966年属什么今年多大| 天天睡不着觉什么原因| 细菌性阴道炎有什么症状| 猫呕吐是什么原因| exp是什么日期| 装模作样是什么生肖| 来月经喝红糖水有什么好处| 石敢当是什么神| 木兮是什么意思| 心衰有什么症状| 2月20是什么星座| 很多条腿的虫子叫什么| 毛泽东什么时候逝世| 祀是什么意思| 颈椎压迫神经手麻吃什么药| 冰箱里有什么细菌| 麻小是什么意思| 什么尾巴长不了| 月经期后是什么期| 什么是沉香木| 什么叫结节| 为什么会湿气重| 忧郁什么意思| 王大治与董洁什么关系| 肺结节挂什么科室| 逢九年应该注意什么有什么禁忌| 菽是什么| kim是什么意思| 簸箕是什么意思| 甲亢适合吃什么食物| 人中浅的女人代表什么| 江西是什么菜系| 每天头疼是什么原因引起的| 废电池乱丢对人体可能造成什么中毒| 山楂和什么泡水喝减肥效果最好| 内心os什么意思| 11是什么生肖| 一般是什么意思| 晚上吃什么减肥快| 水烧开后有白色沉淀物是什么| 糖精是什么| 室上速是什么病| 尿隐血阳性是什么病| 囊性结构是什么意思| 淋巴结肿大是什么样子| 喝枸杞子泡水有什么好处和坏处| 做梦梦见僵尸是什么预兆| 日丙念什么| 引体向上练什么肌肉| 软骨炎是什么病| 猪蹄和什么一起炖好吃| 喝什么能补肾| 牛头马面指什么生肖| 午字五行属什么| 眼镜什么品牌好| 孔子名什么| 上火了喝什么降火最快| 糖尿病患者能吃什么水果| mk属于什么档次| 心肌炎是什么| 地铁什么时候停运| a型血的人容易得什么病| 点天灯是什么意思| 梦见和别人打架是什么意思| 安罗替尼适合什么肿瘤| 体征是什么意思| 鲥鱼是什么鱼| 感冒什么时候传染性最强| 大米发霉是什么样子| 焯水是什么意思| 殖民地是什么意思| 泥丸宫在什么位置| 艾滋病会有什么症状| 神经内科看什么病的| 金银满堂是什么生肖| 死忠粉是什么意思| 花裤子配什么上衣| 阴瑜伽是什么意思| 痴女是什么意思| 发痧是什么原因造成的| 科技皮是什么皮| 血压有点低是什么原因| 密度灶是什么意思| 阴茎进入阴道什么感觉| 什么解酒| l是什么意思| 什么相照| 什么是无性婚姻| 亟须什么意思| 天妇罗是什么| 外感是什么意思| 肝区回声密集是什么意思| 三个水读什么| 前列腺增生伴钙化是什么意思| 髂胫束在什么位置| www是什么意思| 微信附近的人都是些什么人| 为什么脸上老长痘痘| 青蛙趴有什么好处| 7月20号什么星座| mcm是什么牌子| 男朋友过生日送什么礼物最有意义| 结婚有什么好处| 两特两重指的是什么| 什么是阳历| 低压高吃什么食物好| 威化是什么意思| 女人什么眉毛最有福气| cas号是什么意思| 梦见自己理发是什么意思| 工匠精神是什么| 牛奶加咖啡叫什么| 真五行属什么| 心脏不好的人吃什么好| 铃字五行属什么| 埋线是什么| 压抑是什么意思| 扁桃体化脓是什么原因引起的| 信天翁是什么鸟| 肚子响是什么原因| 通宵是什么意思| 雷锋属什么生肖| 正正得什么| 梦见找孩子什么预兆| 不撞南墙不回头是什么意思| 04属什么| 自白是什么意思| 胆巴是什么| 小产后可以吃什么水果| 生物公司是做什么的| 足跟痛是什么原因| 大水冲了龙王庙什么意思| 班门弄斧是什么意思| 甘霖是什么意思| 爱出者爱返福往者福来什么意思| 渗透压低是什么意思| 795是什么意思| 心烦意乱是什么意思| 肛门是什么意思| 林黛玉是个什么样的人| 石女什么意思| 碘化银什么颜色| 淋巴结反应性增生是什么意思| 一什么桌子| 马日冲鼠是什么意思| 夏至吃什么传统食物| 未见明显胚芽是什么意思| 肾萎缩吃什么药好| 感染性疾病科看什么病| 14k金是什么意思| 高碱性食物都有什么| 阿莫西林是什么药| 鸡柳是什么肉| 吃海鲜不能吃什么水果| 肾结石要注意什么| 贫血不能吃什么| 见性成佛是什么意思| 痰多吃什么好| eb病毒iga抗体阳性是什么意思| 卵泡破裂有什么症状| eb是什么意思| 公认是什么意思| 消化道出血吃什么药| 不能吃辛辣是指什么| 什么样的土豆不能吃| 2006属狗的五行缺什么| 一米阳光是什么意思| 坚壁清野什么意思| cashmere是什么意思| 备孕不应该吃什么| 疑难杂症是什么意思| 小儿消化不良吃什么药最好| 什么鱼红烧好吃| 福禄安康是什么意思| 柔和是什么意思| 李白字什么号什么| 心超是检查什么的| 嫦娥是什么生肖| 鲱鱼在中国叫什么鱼| 宫颈小有什么影响| 甲沟炎用什么药好| 粉色药片是什么药| 天蝎座和什么星座不合| pr是什么意思| a货是什么意思| 睡眠障碍应该挂什么科室| bm什么意思| 四肢肿胀是什么原因引起的| 自由意志是什么意思| 九王念什么| 人为什么会抽筋| 一直咳嗽不见好是什么原因| 94年属什么| bella什么意思| 脆生生的什么| 光天化日什么意思| 柠檬泡水喝有什么作用| 作风问题的核心是什么| 身份证x代表什么意思| 四面八方什么生肖| 桂林山水下一句是什么| nm是什么单位| 后背长痘是什么原因| 山梨酸钾是什么| 农历五月是什么月| 胸部ct挂什么科| 睾丸变小是什么原因| 心口下面疼是什么原因| 蛋白肉是什么东西做的| 杂菌阳性是什么意思| 百度

呼和浩特首家电动汽车充电站投入使用

Directory: ../../../ffmpeg/
File: src/libavcodec/motion_est_template.c
Date: 2025-08-04 00:43:16
Exec Total Coverage
Lines: 311 498 62.4%
Functions: 11 17 64.7%
Branches: 228 490 46.5%
Line Branch Exec Source
1 /*
2 * Motion estimation
3 * Copyright (c) 2002-2004 Michael Niedermayer
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 /**
23 * @file
24 * Motion estimation template.
25 */
26
27 #include "libavutil/qsort.h"
28 #include "mpegvideoenc.h"
29
30 //Let us hope gcc will remove the unused vars ...(gcc 3.2.2 seems to do it ...)
31 #define LOAD_COMMON\
32 uint32_t av_unused * const score_map= c->score_map;\
33 const int av_unused xmin= c->xmin;\
34 const int av_unused ymin= c->ymin;\
35 const int av_unused xmax= c->xmax;\
36 const int av_unused ymax= c->ymax;\
37 const uint8_t *mv_penalty = c->current_mv_penalty; \
38 const int pred_x= c->pred_x;\
39 const int pred_y= c->pred_y;\
40
41 #define CHECK_HALF_MV(dx, dy, x, y)\
42 {\
43 const int hx= 2*(x)+(dx);\
44 const int hy= 2*(y)+(dy);\
45 d= cmp_hpel(s, x, y, dx, dy, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);\
46 d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\
47 COPY3_IF_LT(dmin, d, bx, hx, by, hy)\
48 }
49
50 620185 static int hpel_motion_search(MPVEncContext *const s,
51 int *mx_ptr, int *my_ptr, int dmin,
52 int src_index, int ref_index,
53 int size, int h)
54 {
55 620185 MotionEstContext *const c = &s->me;
56 620185 const int mx = *mx_ptr;
57 620185 const int my = *my_ptr;
58 620185 const int penalty_factor= c->sub_penalty_factor;
59 me_cmp_func cmp_sub, chroma_cmp_sub;
60 620185 int bx=2*mx, by=2*my;
61
62 620185 LOAD_COMMON
63 620185 int flags= c->sub_flags;
64
65 //FIXME factorize
66
67 620185 cmp_sub = c->me_sub_cmp[size];
68 620185 chroma_cmp_sub = c->me_sub_cmp[size + 1];
69
70
2/2
✓ Branch 0 taken 772 times.
✓ Branch 1 taken 619413 times.
 620185 if(c->skip){ //FIXME move out of hpel?
71 772 *mx_ptr = 0;
72 772 *my_ptr = 0;
73 772 return dmin;
74 }
75
76
2/2
✓ Branch 0 taken 208806 times.
✓ Branch 1 taken 410607 times.
 619413 if(c->avctx->me_cmp != c->avctx->me_sub_cmp){
77 208806 dmin= cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);
78
6/6
✓ Branch 0 taken 41191 times.
✓ Branch 1 taken 167615 times.
✓ Branch 2 taken 21966 times.
✓ Branch 3 taken 19225 times.
✓ Branch 4 taken 1116 times.
✓ Branch 5 taken 20850 times.
 208806 if(mx || my || size>0)
79 187956 dmin += (mv_penalty[2*mx - pred_x] + mv_penalty[2*my - pred_y])*penalty_factor;
80 }
81
82
6/6
✓ Branch 0 taken 615297 times.
✓ Branch 1 taken 4116 times.
✓ Branch 2 taken 611939 times.
✓ Branch 3 taken 3358 times.
✓ Branch 4 taken 608784 times.
✓ Branch 5 taken 3155 times.
 619413 if (mx > xmin && mx < xmax &&
83
2/2
✓ Branch 0 taken 605497 times.
✓ Branch 1 taken 3287 times.
 608784 my > ymin && my < ymax) {
84 605497 int d= dmin;
85 605497 const int index = my * (1 << ME_MAP_SHIFT) + mx;
86 605497 const int t= score_map[(index-(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)]
87 605497 + (mv_penalty[bx - pred_x] + mv_penalty[by-2 - pred_y])*c->penalty_factor;
88 605497 const int l= score_map[(index- 1 )&(ME_MAP_SIZE-1)]
89 605497 + (mv_penalty[bx-2 - pred_x] + mv_penalty[by - pred_y])*c->penalty_factor;
90 605497 const int r= score_map[(index+ 1 )&(ME_MAP_SIZE-1)]
91 605497 + (mv_penalty[bx+2 - pred_x] + mv_penalty[by - pred_y])*c->penalty_factor;
92 605497 const int b= score_map[(index+(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)]
93 605497 + (mv_penalty[bx - pred_x] + mv_penalty[by+2 - pred_y])*c->penalty_factor;
94
95 #if defined(ASSERT_LEVEL) && ASSERT_LEVEL > 1
96 unsigned key;
97 unsigned map_generation= c->map_generation;
98 key = (my - 1) * (1 << ME_MAP_MV_BITS) + (mx) + map_generation;
99 av_assert2(c->map[(index-(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)] == key);
100 key = (my + 1) * (1 << ME_MAP_MV_BITS) + (mx) + map_generation;
101 av_assert2(c->map[(index+(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)] == key);
102 key = (my) * (1 << ME_MAP_MV_BITS) + (mx + 1) + map_generation;
103 av_assert2(c->map[(index+1)&(ME_MAP_SIZE-1)] == key);
104 key = (my) * (1 << ME_MAP_MV_BITS) + (mx - 1) + map_generation;
105 av_assert2(c->map[(index-1)&(ME_MAP_SIZE-1)] == key);
106 #endif
107
2/2
✓ Branch 0 taken 300373 times.
✓ Branch 1 taken 305124 times.
 605497 if(t<=b){
108 300373 CHECK_HALF_MV(0, 1, mx ,my-1)
109
2/2
✓ Branch 0 taken 181724 times.
✓ Branch 1 taken 118649 times.
 300373 if(l<=r){
110 181724 CHECK_HALF_MV(1, 1, mx-1, my-1)
111
2/2
✓ Branch 0 taken 94603 times.
✓ Branch 1 taken 87121 times.
 181724 if(t+r<=b+l){
112 94603 CHECK_HALF_MV(1, 1, mx , my-1)
113 }else{
114 87121 CHECK_HALF_MV(1, 1, mx-1, my )
115 }
116 181724 CHECK_HALF_MV(1, 0, mx-1, my )
117 }else{
118 118649 CHECK_HALF_MV(1, 1, mx , my-1)
119
2/2
✓ Branch 0 taken 61052 times.
✓ Branch 1 taken 57597 times.
 118649 if(t+l<=b+r){
120 61052 CHECK_HALF_MV(1, 1, mx-1, my-1)
121 }else{
122 57597 CHECK_HALF_MV(1, 1, mx , my )
123 }
124 118649 CHECK_HALF_MV(1, 0, mx , my )
125 }
126 }else{
127
2/2
✓ Branch 0 taken 119010 times.
✓ Branch 1 taken 186114 times.
 305124 if(l<=r){
128
2/2
✓ Branch 0 taken 54315 times.
✓ Branch 1 taken 64695 times.
 119010 if(t+l<=b+r){
129 54315 CHECK_HALF_MV(1, 1, mx-1, my-1)
130 }else{
131 64695 CHECK_HALF_MV(1, 1, mx , my )
132 }
133 119010 CHECK_HALF_MV(1, 0, mx-1, my)
134 119010 CHECK_HALF_MV(1, 1, mx-1, my)
135 }else{
136
2/2
✓ Branch 0 taken 91344 times.
✓ Branch 1 taken 94770 times.
 186114 if(t+r<=b+l){
137 91344 CHECK_HALF_MV(1, 1, mx , my-1)
138 }else{
139 94770 CHECK_HALF_MV(1, 1, mx-1, my)
140 }
141 186114 CHECK_HALF_MV(1, 0, mx , my)
142 186114 CHECK_HALF_MV(1, 1, mx , my)
143 }
144 305124 CHECK_HALF_MV(0, 1, mx , my)
145 }
146 av_assert2(bx >= xmin*2 && bx <= xmax*2 && by >= ymin*2 && by <= ymax*2);
147 }
148
149 619413 *mx_ptr = bx;
150 619413 *my_ptr = by;
151
152 619413 return dmin;
153 }
154
155 106800 static int no_sub_motion_search(MPVEncContext *const s,
156 int *mx_ptr, int *my_ptr, int dmin,
157 int src_index, int ref_index,
158 int size, int h)
159 {
160 106800 (*mx_ptr) *= 2;
161 106800 (*my_ptr) *= 2;
162 106800 return dmin;
163 }
164
165 954789 static inline int get_mb_score(MPVEncContext *const s, int mx, int my,
166 int src_index, int ref_index, int size,
167 int h, int add_rate)
168 {
169 954789 MotionEstContext *const c = &s->me;
170 954789 const int penalty_factor= c->mb_penalty_factor;
171 954789 const int flags= c->mb_flags;
172 954789 const int qpel= flags & FLAG_QPEL;
173 954789 const int mask= 1+2*qpel;
174 me_cmp_func cmp_sub, chroma_cmp_sub;
175 int d;
176
177 954789 LOAD_COMMON
178
179 //FIXME factorize
180
181 954789 cmp_sub = c->mb_cmp[size];
182 954789 chroma_cmp_sub = c->mb_cmp[size + 1];
183
184 954789 d= cmp(s, mx>>(qpel+1), my>>(qpel+1), mx&mask, my&mask, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);
185 //FIXME check cbp before adding penalty for (0,0) vector
186
7/8
✓ Branch 0 taken 387249 times.
✓ Branch 1 taken 567540 times.
✓ Branch 2 taken 75312 times.
✓ Branch 3 taken 311937 times.
✓ Branch 4 taken 40032 times.
✓ Branch 5 taken 35280 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 40032 times.
 954789 if(add_rate && (mx || my || size>0))
187 347217 d += (mv_penalty[mx - pred_x] + mv_penalty[my - pred_y])*penalty_factor;
188
189 954789 return d;
190 }
191
192 567540 int ff_get_mb_score(MPVEncContext *const s, int mx, int my, int src_index,
193 int ref_index, int size, int h, int add_rate)
194 {
195 567540 return get_mb_score(s, mx, my, src_index, ref_index, size, h, add_rate);
196 }
197
198 #define CHECK_QUARTER_MV(dx, dy, x, y)\
199 {\
200 const int hx= 4*(x)+(dx);\
201 const int hy= 4*(y)+(dy);\
202 d= cmp_qpel(s, x, y, dx, dy, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
203 d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\
204 COPY3_IF_LT(dmin, d, bx, hx, by, hy)\
205 }
206
207 750324 static int qpel_motion_search(MPVEncContext *const s,
208 int *mx_ptr, int *my_ptr, int dmin,
209 int src_index, int ref_index,
210 int size, int h)
211 {
212 750324 MotionEstContext *const c = &s->me;
213 750324 const int mx = *mx_ptr;
214 750324 const int my = *my_ptr;
215 750324 const int penalty_factor= c->sub_penalty_factor;
216 750324 const unsigned map_generation = c->map_generation;
217 750324 const int subpel_quality= c->avctx->me_subpel_quality;
218 750324 uint32_t *map= c->map;
219 me_cmp_func cmpf, chroma_cmpf;
220 me_cmp_func cmp_sub, chroma_cmp_sub;
221
222 750324 LOAD_COMMON
223 750324 int flags= c->sub_flags;
224
225 750324 cmpf = c->me_cmp[size];
226 750324 chroma_cmpf = c->me_cmp[size + 1]; // FIXME: factorize
227 //FIXME factorize
228
229 750324 cmp_sub = c->me_sub_cmp[size];
230 750324 chroma_cmp_sub = c->me_sub_cmp[size + 1];
231
232
2/2
✓ Branch 0 taken 1473 times.
✓ Branch 1 taken 748851 times.
 750324 if(c->skip){ //FIXME somehow move up (benchmark)
233 1473 *mx_ptr = 0;
234 1473 *my_ptr = 0;
235 1473 return dmin;
236 }
237
238
2/2
✓ Branch 0 taken 187104 times.
✓ Branch 1 taken 561747 times.
 748851 if(c->avctx->me_cmp != c->avctx->me_sub_cmp){
239 187104 dmin= cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);
240
6/6
✓ Branch 0 taken 39985 times.
✓ Branch 1 taken 147119 times.
✓ Branch 2 taken 23595 times.
✓ Branch 3 taken 16390 times.
✓ Branch 4 taken 719 times.
✓ Branch 5 taken 22876 times.
 187104 if(mx || my || size>0)
241 164228 dmin += (mv_penalty[4*mx - pred_x] + mv_penalty[4*my - pred_y])*penalty_factor;
242 }
243
244
6/6
✓ Branch 0 taken 746821 times.
✓ Branch 1 taken 2030 times.
✓ Branch 2 taken 745133 times.
✓ Branch 3 taken 1688 times.
✓ Branch 4 taken 744866 times.
✓ Branch 5 taken 267 times.
 748851 if (mx > xmin && mx < xmax &&
245
2/2
✓ Branch 0 taken 744433 times.
✓ Branch 1 taken 433 times.
 744866 my > ymin && my < ymax) {
246 744433 int bx=4*mx, by=4*my;
247 744433 int d= dmin;
248 int i, nx, ny;
249 744433 const int index = my * (1 << ME_MAP_SHIFT) + mx;
250 744433 const int t= score_map[(index-(1<<ME_MAP_SHIFT) )&(ME_MAP_SIZE-1)];
251 744433 const int l= score_map[(index- 1 )&(ME_MAP_SIZE-1)];
252 744433 const int r= score_map[(index+ 1 )&(ME_MAP_SIZE-1)];
253 744433 const int b= score_map[(index+(1<<ME_MAP_SHIFT) )&(ME_MAP_SIZE-1)];
254 744433 const int c= score_map[(index )&(ME_MAP_SIZE-1)];
255 int best[8];
256 int best_pos[8][2];
257
258 744433 memset(best, 64, sizeof(int)*8);
259
2/2
✓ Branch 0 taken 246029 times.
✓ Branch 1 taken 498404 times.
 744433 if(s->me.dia_size>=2){
260 246029 const int tl= score_map[(index-(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];
261 246029 const int bl= score_map[(index+(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];
262 246029 const int tr= score_map[(index-(1<<ME_MAP_SHIFT)+1)&(ME_MAP_SIZE-1)];
263 246029 const int br= score_map[(index+(1<<ME_MAP_SHIFT)+1)&(ME_MAP_SIZE-1)];
264
265
2/2
✓ Branch 0 taken 1722203 times.
✓ Branch 1 taken 246029 times.
 1968232 for(ny= -3; ny <= 3; ny++){
266
2/2
✓ Branch 0 taken 12055421 times.
✓ Branch 1 taken 1722203 times.
 13777624 for(nx= -3; nx <= 3; nx++){
267 //FIXME this could overflow (unlikely though)
268 12055421 const int64_t t2= nx*nx*(tr + tl - 2*t) + 4*nx*(tr-tl) + 32*t;
269 12055421 const int64_t c2= nx*nx*( r + l - 2*c) + 4*nx*( r- l) + 32*c;
270 12055421 const int64_t b2= nx*nx*(br + bl - 2*b) + 4*nx*(br-bl) + 32*b;
271 12055421 int score= (ny*ny*(b2 + t2 - 2*c2) + 4*ny*(b2 - t2) + 32*c2 + 512)>>10;
272 int i;
273
274
4/4
✓ Branch 0 taken 1722203 times.
✓ Branch 1 taken 10333218 times.
✓ Branch 2 taken 246029 times.
✓ Branch 3 taken 1476174 times.
 12055421 if((nx&3)==0 && (ny&3)==0) continue;
275
276 11809392 score += (mv_penalty[4*mx + nx - pred_x] + mv_penalty[4*my + ny - pred_y])*penalty_factor;
277
278 // if(nx&1) score-=1024*c->penalty_factor;
279 // if(ny&1) score-=1024*c->penalty_factor;
280
281
2/2
✓ Branch 0 taken 65010767 times.
✓ Branch 1 taken 5686077 times.
 70696844 for(i=0; i<8; i++){
282
2/2
✓ Branch 0 taken 6123315 times.
✓ Branch 1 taken 58887452 times.
 65010767 if(score < best[i]){
283 6123315 memmove(&best[i+1], &best[i], sizeof(int)*(7-i));
284 6123315 memmove(&best_pos[i + 1], &best_pos[i], sizeof(*best_pos) * (7 - i));
285 6123315 best[i]= score;
286 6123315 best_pos[i][0]= nx + 4*mx;
287 6123315 best_pos[i][1]= ny + 4*my;
288 6123315 break;
289 }
290 }
291 }
292 }
293 }else{
294 int tl;
295 //FIXME this could overflow (unlikely though)
296 498404 const int cx = 4*(r - l);
297 498404 const int cx2= r + l - 2*c;
298 498404 const int cy = 4*(b - t);
299 498404 const int cy2= b + t - 2*c;
300 int cxy;
301
302 498404 if (map[(index - (1 << ME_MAP_SHIFT) - 1) & (ME_MAP_SIZE - 1)] ==
303
2/2
✓ Branch 0 taken 234525 times.
✓ Branch 1 taken 263879 times.
 498404 (my - 1) * (1 << ME_MAP_MV_BITS) + (mx - 1) + map_generation) {
304 234525 tl= score_map[(index-(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];
305 }else{
306 263879 tl= cmp(s, mx-1, my-1, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);//FIXME wrong if chroma me is different
307 }
308
309 498404 cxy= 2*tl + (cx + cy)/4 - (cx2 + cy2) - 2*c;
310
311 av_assert2(16*cx2 + 4*cx + 32*c == 32*r);
312 av_assert2(16*cx2 - 4*cx + 32*c == 32*l);
313 av_assert2(16*cy2 + 4*cy + 32*c == 32*b);
314 av_assert2(16*cy2 - 4*cy + 32*c == 32*t);
315 av_assert2(16*cxy + 16*cy2 + 16*cx2 - 4*cy - 4*cx + 32*c == 32*tl);
316
317
2/2
✓ Branch 0 taken 3488828 times.
✓ Branch 1 taken 498404 times.
 3987232 for(ny= -3; ny <= 3; ny++){
318
2/2
✓ Branch 0 taken 24421796 times.
✓ Branch 1 taken 3488828 times.
 27910624 for(nx= -3; nx <= 3; nx++){
319 //FIXME this could overflow (unlikely though)
320 24421796 int score= ny*nx*cxy + nx*nx*cx2 + ny*ny*cy2 + nx*cx + ny*cy + 32*c; //FIXME factor
321 int i;
322
323
4/4
✓ Branch 0 taken 3488828 times.
✓ Branch 1 taken 20932968 times.
✓ Branch 2 taken 498404 times.
✓ Branch 3 taken 2990424 times.
 24421796 if((nx&3)==0 && (ny&3)==0) continue;
324
325 23923392 score += 32*(mv_penalty[4*mx + nx - pred_x] + mv_penalty[4*my + ny - pred_y])*penalty_factor;
326 // if(nx&1) score-=32*c->penalty_factor;
327 // if(ny&1) score-=32*c->penalty_factor;
328
329
2/2
✓ Branch 0 taken 130437944 times.
✓ Branch 1 taken 11245891 times.
 141683835 for(i=0; i<8; i++){
330
2/2
✓ Branch 0 taken 12677501 times.
✓ Branch 1 taken 117760443 times.
 130437944 if(score < best[i]){
331 12677501 memmove(&best[i+1], &best[i], sizeof(int)*(7-i));
332 12677501 memmove(best_pos[i + 1], best_pos[i], sizeof(best_pos[0]) * (7 - i));
333 12677501 best[i]= score;
334 12677501 best_pos[i][0]= nx + 4*mx;
335 12677501 best_pos[i][1]= ny + 4*my;
336 12677501 break;
337 }
338 }
339 }
340 }
341 }
342
2/2
✓ Branch 0 taken 5955464 times.
✓ Branch 1 taken 744433 times.
 6699897 for(i=0; i<subpel_quality; i++){
343 5955464 nx= best_pos[i][0];
344 5955464 ny= best_pos[i][1];
345 5955464 CHECK_QUARTER_MV(nx&3, ny&3, nx>>2, ny>>2)
346 }
347
348 av_assert2(bx >= xmin*4 && bx <= xmax*4 && by >= ymin*4 && by <= ymax*4);
349
350 744433 *mx_ptr = bx;
351 744433 *my_ptr = by;
352 }else{
353 4418 *mx_ptr =4*mx;
354 4418 *my_ptr =4*my;
355 }
356
357 748851 return dmin;
358 }
359
360
361 #define CHECK_MV(x,y)\
362 {\
363 const unsigned key = ((unsigned)(y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
364 const int index= (((unsigned)(y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
365 av_assert2((x) >= xmin);\
366 av_assert2((x) <= xmax);\
367 av_assert2((y) >= ymin);\
368 av_assert2((y) <= ymax);\
369 if(map[index]!=key){\
370 d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
371 map[index]= key;\
372 score_map[index]= d;\
373 d += (mv_penalty[((x)*(1<<shift))-pred_x] + mv_penalty[((y)*(1<<shift))-pred_y])*penalty_factor;\
374 COPY3_IF_LT(dmin, d, best[0], x, best[1], y)\
375 }\
376 }
377
378 #define CHECK_CLIPPED_MV(ax,ay)\
379 {\
380 const int Lx= ax;\
381 const int Ly= ay;\
382 const int Lx2= FFMAX(xmin, FFMIN(Lx, xmax));\
383 const int Ly2= FFMAX(ymin, FFMIN(Ly, ymax));\
384 CHECK_MV(Lx2, Ly2)\
385 }
386
387 #define CHECK_MV_DIR(x,y,new_dir)\
388 {\
389 const unsigned key = ((unsigned)(y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
390 const int index= (((unsigned)(y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
391 if(map[index]!=key){\
392 d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
393 map[index]= key;\
394 score_map[index]= d;\
395 d += (mv_penalty[(int)((unsigned)(x)<<shift)-pred_x] + mv_penalty[(int)((unsigned)(y)<<shift)-pred_y])*penalty_factor;\
396 if(d<dmin){\
397 best[0]=x;\
398 best[1]=y;\
399 dmin=d;\
400 next_dir= new_dir;\
401 }\
402 }\
403 }
404
405 #define check(x,y,S,v)\
406 if( (x)<(xmin<<(S)) ) av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d xmin" #v, xmin, (x), (y), s->c.mb_x, s->c.mb_y);\
407 if( (x)>(xmax<<(S)) ) av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d xmax" #v, xmax, (x), (y), s->c.mb_x, s->c.mb_y);\
408 if( (y)<(ymin<<(S)) ) av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d ymin" #v, ymin, (x), (y), s->c.mb_x, s->c.mb_y);\
409 if( (y)>(ymax<<(S)) ) av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d ymax" #v, ymax, (x), (y), s->c.mb_x, s->c.mb_y);\
410
411 #define LOAD_COMMON2\
412 uint32_t *map= c->map;\
413 const int qpel= flags&FLAG_QPEL;\
414 const int shift= 1+qpel;\
415
416 5705386 static av_always_inline int small_diamond_search(MPVEncContext *const s, int *best, int dmin,
417 int src_index, int ref_index, const int penalty_factor,
418 int size, int h, int flags)
419 {
420 5705386 MotionEstContext *const c = &s->me;
421 me_cmp_func cmpf, chroma_cmpf;
422 5705386 int next_dir=-1;
423 5705386 LOAD_COMMON
424 5705386 LOAD_COMMON2
425 5705386 unsigned map_generation = c->map_generation;
426
427 5705386 cmpf = c->me_cmp[size];
428 5705386 chroma_cmpf = c->me_cmp[size + 1];
429
430 { /* ensure that the best point is in the MAP as h/qpel refinement needs it */
431 5705386 const unsigned key = ((unsigned)best[1]<<ME_MAP_MV_BITS) + best[0] + map_generation;
432 5705386 const int index= (((unsigned)best[1]<<ME_MAP_SHIFT) + best[0])&(ME_MAP_SIZE-1);
433
2/2
✓ Branch 0 taken 35686 times.
✓ Branch 1 taken 5669700 times.
 5705386 if (map[index] != key) { // this will be executed only very rarely
434 35686 score_map[index]= cmp(s, best[0], best[1], 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
435 35686 map[index]= key;
436 }
437 }
438
439 1749036 for(;;){
440 int d;
441 7454422 const int dir= next_dir;
442 7454422 const int x= best[0];
443 7454422 const int y= best[1];
444 7454422 next_dir=-1;
445
446
8/8
✓ Branch 0 taken 6888018 times.
✓ Branch 1 taken 566404 times.
✓ Branch 2 taken 6765733 times.
✓ Branch 3 taken 122285 times.
✓ Branch 4 taken 3732749 times.
✓ Branch 5 taken 3032984 times.
✓ Branch 7 taken 590799 times.
✓ Branch 8 taken 3141950 times.
 7454422 if(dir!=2 && x>xmin) CHECK_MV_DIR(x-1, y , 0)
447
8/8
✓ Branch 0 taken 7068937 times.
✓ Branch 1 taken 385485 times.
✓ Branch 2 taken 6914555 times.
✓ Branch 3 taken 154382 times.
✓ Branch 4 taken 4128029 times.
✓ Branch 5 taken 2786526 times.
✓ Branch 7 taken 389724 times.
✓ Branch 8 taken 3738305 times.
 7454422 if(dir!=3 && y>ymin) CHECK_MV_DIR(x , y-1, 1)
448
8/8
✓ Branch 0 taken 6993183 times.
✓ Branch 1 taken 461239 times.
✓ Branch 2 taken 6884804 times.
✓ Branch 3 taken 108379 times.
✓ Branch 4 taken 4482291 times.
✓ Branch 5 taken 2402513 times.
✓ Branch 7 taken 652018 times.
✓ Branch 8 taken 3830273 times.
 7454422 if(dir!=0 && x<xmax) CHECK_MV_DIR(x+1, y , 2)
449
8/8
✓ Branch 0 taken 7118514 times.
✓ Branch 1 taken 335908 times.
✓ Branch 2 taken 6985146 times.
✓ Branch 3 taken 133368 times.
✓ Branch 4 taken 4770758 times.
✓ Branch 5 taken 2214388 times.
✓ Branch 7 taken 385485 times.
✓ Branch 8 taken 4385273 times.
 7454422 if(dir!=1 && y<ymax) CHECK_MV_DIR(x , y+1, 3)
450
451
2/2
✓ Branch 0 taken 5705386 times.
✓ Branch 1 taken 1749036 times.
 7454422 if(next_dir==-1){
452 5705386 return dmin;
453 }
454 }
455 }
456
457 ✗ static int funny_diamond_search(MPVEncContext *const s, int *best, int dmin,
458 int src_index, int ref_index, const int penalty_factor,
459 int size, int h, int flags)
460 {
461 ✗ MotionEstContext *const c = &s->me;
462 me_cmp_func cmpf, chroma_cmpf;
463 int dia_size;
464 ✗ LOAD_COMMON
465 ✗ LOAD_COMMON2
466 ✗ unsigned map_generation = c->map_generation;
467
468 ✗ cmpf = c->me_cmp[size];
469 ✗ chroma_cmpf = c->me_cmp[size + 1];
470
471 ✗ for(dia_size=1; dia_size<=4; dia_size++){
472 int dir;
473 ✗ const int x= best[0];
474 ✗ const int y= best[1];
475
476 ✗ if(dia_size&(dia_size-1)) continue;
477
478 ✗ if( x + dia_size > xmax
479 ✗ || x - dia_size < xmin
480 ✗ || y + dia_size > ymax
481 ✗ || y - dia_size < ymin)
482 ✗ continue;
483
484 ✗ for(dir= 0; dir<dia_size; dir+=2){
485 int d;
486
487 ✗ CHECK_MV(x + dir , y + dia_size - dir);
488 ✗ CHECK_MV(x + dia_size - dir, y - dir );
489 ✗ CHECK_MV(x - dir , y - dia_size + dir);
490 ✗ CHECK_MV(x - dia_size + dir, y + dir );
491 }
492
493 ✗ if(x!=best[0] || y!=best[1])
494 ✗ dia_size=0;
495 }
496 ✗ return dmin;
497 }
498
499 ✗ static int hex_search(MPVEncContext *const s, int *best, int dmin,
500 int src_index, int ref_index, const int penalty_factor,
501 int size, int h, int flags, int dia_size)
502 {
503 ✗ MotionEstContext *const c = &s->me;
504 me_cmp_func cmpf, chroma_cmpf;
505 ✗ LOAD_COMMON
506 ✗ LOAD_COMMON2
507 ✗ unsigned map_generation = c->map_generation;
508 int x,y,d;
509 ✗ const int dec= dia_size & (dia_size-1);
510
511 ✗ cmpf = c->me_cmp[size];
512 ✗ chroma_cmpf = c->me_cmp[size + 1];
513
514 ✗ for(;dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
515 do{
516 ✗ x= best[0];
517 ✗ y= best[1];
518
519 ✗ CHECK_CLIPPED_MV(x -dia_size , y);
520 ✗ CHECK_CLIPPED_MV(x+ dia_size , y);
521 ✗ CHECK_CLIPPED_MV(x+( dia_size>>1), y+dia_size);
522 ✗ CHECK_CLIPPED_MV(x+( dia_size>>1), y-dia_size);
523 ✗ if(dia_size>1){
524 ✗ CHECK_CLIPPED_MV(x+(-dia_size>>1), y+dia_size);
525 ✗ CHECK_CLIPPED_MV(x+(-dia_size>>1), y-dia_size);
526 }
527 ✗ }while(best[0] != x || best[1] != y);
528 }
529
530 ✗ return dmin;
531 }
532
533 ✗ static int l2s_dia_search(MPVEncContext *const s, int *best, int dmin,
534 int src_index, int ref_index, const int penalty_factor,
535 int size, int h, int flags)
536 {
537 ✗ MotionEstContext *const c = &s->me;
538 me_cmp_func cmpf, chroma_cmpf;
539 ✗ LOAD_COMMON
540 ✗ LOAD_COMMON2
541 ✗ unsigned map_generation = c->map_generation;
542 int x,y,i,d;
543 ✗ int dia_size= c->dia_size&0xFF;
544 ✗ const int dec= dia_size & (dia_size-1);
545 static const int hex[8][2]={{-2, 0}, {-1,-1}, { 0,-2}, { 1,-1},
546 { 2, 0}, { 1, 1}, { 0, 2}, {-1, 1}};
547
548 ✗ cmpf = c->me_cmp[size];
549 ✗ chroma_cmpf = c->me_cmp[size + 1];
550
551 ✗ for(; dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
552 do{
553 ✗ x= best[0];
554 ✗ y= best[1];
555 ✗ for(i=0; i<8; i++){
556 ✗ CHECK_CLIPPED_MV(x+hex[i][0]*dia_size, y+hex[i][1]*dia_size);
557 }
558 ✗ }while(best[0] != x || best[1] != y);
559 }
560
561 ✗ x= best[0];
562 ✗ y= best[1];
563 ✗ CHECK_CLIPPED_MV(x+1, y);
564 ✗ CHECK_CLIPPED_MV(x, y+1);
565 ✗ CHECK_CLIPPED_MV(x-1, y);
566 ✗ CHECK_CLIPPED_MV(x, y-1);
567
568 ✗ return dmin;
569 }
570
571 ✗ static int umh_search(MPVEncContext *const s, int *best, int dmin,
572 int src_index, int ref_index, const int penalty_factor,
573 int size, int h, int flags)
574 {
575 ✗ MotionEstContext *const c = &s->me;
576 me_cmp_func cmpf, chroma_cmpf;
577 ✗ LOAD_COMMON
578 ✗ LOAD_COMMON2
579 ✗ unsigned map_generation = c->map_generation;
580 int x,y,x2,y2, i, j, d;
581 ✗ const int dia_size= c->dia_size&0xFE;
582 static const int hex[16][2]={{-4,-2}, {-4,-1}, {-4, 0}, {-4, 1}, {-4, 2},
583 { 4,-2}, { 4,-1}, { 4, 0}, { 4, 1}, { 4, 2},
584 {-2, 3}, { 0, 4}, { 2, 3},
585 {-2,-3}, { 0,-4}, { 2,-3},};
586
587 ✗ cmpf = c->me_cmp[size];
588 ✗ chroma_cmpf = c->me_cmp[size + 1];
589
590 ✗ x= best[0];
591 ✗ y= best[1];
592 ✗ for(x2=FFMAX(x-dia_size+1, xmin); x2<=FFMIN(x+dia_size-1,xmax); x2+=2){
593 ✗ CHECK_MV(x2, y);
594 }
595 ✗ for(y2=FFMAX(y-dia_size/2+1, ymin); y2<=FFMIN(y+dia_size/2-1,ymax); y2+=2){
596 ✗ CHECK_MV(x, y2);
597 }
598
599 ✗ x= best[0];
600 ✗ y= best[1];
601 ✗ for(y2=FFMAX(y-2, ymin); y2<=FFMIN(y+2,ymax); y2++){
602 ✗ for(x2=FFMAX(x-2, xmin); x2<=FFMIN(x+2,xmax); x2++){
603 ✗ CHECK_MV(x2, y2);
604 }
605 }
606
607 //FIXME prevent the CLIP stuff
608
609 ✗ for(j=1; j<=dia_size/4; j++){
610 ✗ for(i=0; i<16; i++){
611 ✗ CHECK_CLIPPED_MV(x+hex[i][0]*j, y+hex[i][1]*j);
612 }
613 }
614
615 ✗ return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, 2);
616 }
617
618 ✗ static int full_search(MPVEncContext *const s, int *best, int dmin,
619 int src_index, int ref_index, const int penalty_factor,
620 int size, int h, int flags)
621 {
622 ✗ MotionEstContext *const c = &s->me;
623 me_cmp_func cmpf, chroma_cmpf;
624 ✗ LOAD_COMMON
625 ✗ LOAD_COMMON2
626 ✗ unsigned map_generation = c->map_generation;
627 int x,y, d;
628 ✗ const int dia_size= c->dia_size&0xFF;
629
630 ✗ cmpf = c->me_cmp[size];
631 ✗ chroma_cmpf = c->me_cmp[size + 1];
632
633 ✗ for(y=FFMAX(-dia_size, ymin); y<=FFMIN(dia_size,ymax); y++){
634 ✗ for(x=FFMAX(-dia_size, xmin); x<=FFMIN(dia_size,xmax); x++){
635 ✗ CHECK_MV(x, y);
636 }
637 }
638
639 ✗ x= best[0];
640 ✗ y= best[1];
641 ✗ d= dmin;
642 ✗ CHECK_CLIPPED_MV(x , y);
643 ✗ CHECK_CLIPPED_MV(x+1, y);
644 ✗ CHECK_CLIPPED_MV(x, y+1);
645 ✗ CHECK_CLIPPED_MV(x-1, y);
646 ✗ CHECK_CLIPPED_MV(x, y-1);
647 ✗ best[0]= x;
648 ✗ best[1]= y;
649
650 ✗ return d;
651 }
652
653 #define SAB_CHECK_MV(ax,ay)\
654 {\
655 const unsigned key = ((ay)<<ME_MAP_MV_BITS) + (ax) + map_generation;\
656 const int index= (((ay)<<ME_MAP_SHIFT) + (ax))&(ME_MAP_SIZE-1);\
657 if(map[index]!=key){\
658 d= cmp(s, ax, ay, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
659 map[index]= key;\
660 score_map[index]= d;\
661 d += (mv_penalty[((ax)<<shift)-pred_x] + mv_penalty[((ay)<<shift)-pred_y])*penalty_factor;\
662 if(d < minima[minima_count-1].height){\
663 int j=0;\
664 \
665 while(d >= minima[j].height) j++;\
666 \
667 memmove(&minima [j+1], &minima [j], (minima_count - j - 1)*sizeof(Minima));\
668 \
669 minima[j].checked= 0;\
670 minima[j].height= d;\
671 minima[j].x= ax;\
672 minima[j].y= ay;\
673 \
674 i=-1;\
675 continue;\
676 }\
677 }\
678 }
679
680 #define MAX_SAB_SIZE ME_MAP_SIZE
681 ✗ static int sab_diamond_search(MPVEncContext *const s, int *best, int dmin,
682 int src_index, int ref_index, const int penalty_factor,
683 int size, int h, int flags)
684 {
685 ✗ MotionEstContext *const c = &s->me;
686 me_cmp_func cmpf, chroma_cmpf;
687 Minima minima[MAX_SAB_SIZE];
688 ✗ const int minima_count= FFABS(c->dia_size);
689 int i, j;
690 ✗ LOAD_COMMON
691 ✗ LOAD_COMMON2
692 ✗ unsigned map_generation = c->map_generation;
693
694 av_assert1(minima_count <= MAX_SAB_SIZE);
695
696 ✗ cmpf = c->me_cmp[size];
697 ✗ chroma_cmpf = c->me_cmp[size + 1];
698
699 /*Note j<MAX_SAB_SIZE is needed if MAX_SAB_SIZE < ME_MAP_SIZE as j can
700 become larger due to MVs overflowing their ME_MAP_MV_BITS bits space in map
701 */
702 ✗ for(j=i=0; i<ME_MAP_SIZE && j<MAX_SAB_SIZE; i++){
703 ✗ uint32_t key= map[i];
704
705 ✗ key += (1<<(ME_MAP_MV_BITS-1)) + (1<<(2*ME_MAP_MV_BITS-1));
706
707 ✗ if ((key & (-(1 << (2 * ME_MAP_MV_BITS)))) != map_generation)
708 ✗ continue;
709
710 ✗ minima[j].height= score_map[i];
711 ✗ minima[j].x= key & ((1<<ME_MAP_MV_BITS)-1); key>>=ME_MAP_MV_BITS;
712 ✗ minima[j].y= key & ((1<<ME_MAP_MV_BITS)-1);
713 ✗ minima[j].x-= (1<<(ME_MAP_MV_BITS-1));
714 ✗ minima[j].y-= (1<<(ME_MAP_MV_BITS-1));
715
716 // all entries in map should be in range except if the mv overflows their ME_MAP_MV_BITS bits space
717 ✗ if( minima[j].x > xmax || minima[j].x < xmin
718 ✗ || minima[j].y > ymax || minima[j].y < ymin)
719 ✗ continue;
720
721 ✗ minima[j].checked=0;
722 ✗ if(minima[j].x || minima[j].y)
723 ✗ minima[j].height+= (mv_penalty[((minima[j].x)<<shift)-pred_x] + mv_penalty[((minima[j].y)<<shift)-pred_y])*penalty_factor;
724
725 ✗ j++;
726 }
727
728 ✗ AV_QSORT(minima, j, Minima, minima_cmp);
729
730 ✗ for(; j<minima_count; j++){
731 ✗ minima[j].height=256*256*256*64;
732 ✗ minima[j].checked=0;
733 ✗ minima[j].x= minima[j].y=0;
734 }
735
736 ✗ for(i=0; i<minima_count; i++){
737 ✗ const int x= minima[i].x;
738 ✗ const int y= minima[i].y;
739 int d;
740
741 ✗ if(minima[i].checked) continue;
742
743 ✗ if( x >= xmax || x <= xmin
744 ✗ || y >= ymax || y <= ymin)
745 ✗ continue;
746
747 ✗ SAB_CHECK_MV(x-1, y)
748 ✗ SAB_CHECK_MV(x+1, y)
749 ✗ SAB_CHECK_MV(x , y-1)
750 ✗ SAB_CHECK_MV(x , y+1)
751
752 ✗ minima[i].checked= 1;
753 }
754
755 ✗ best[0]= minima[0].x;
756 ✗ best[1]= minima[0].y;
757 ✗ dmin= minima[0].height;
758
759 ✗ if( best[0] < xmax && best[0] > xmin
760 ✗ && best[1] < ymax && best[1] > ymin){
761 int d;
762 // ensure that the reference samples for hpel refinement are in the map
763 ✗ CHECK_MV(best[0]-1, best[1])
764 ✗ CHECK_MV(best[0]+1, best[1])
765 ✗ CHECK_MV(best[0], best[1]-1)
766 ✗ CHECK_MV(best[0], best[1]+1)
767 }
768 ✗ return dmin;
769 }
770
771 250380 static int var_diamond_search(MPVEncContext *const s, int *best, int dmin,
772 int src_index, int ref_index, const int penalty_factor,
773 int size, int h, int flags)
774 {
775 250380 MotionEstContext *const c = &s->me;
776 me_cmp_func cmpf, chroma_cmpf;
777 int dia_size;
778 250380 LOAD_COMMON
779 250380 LOAD_COMMON2
780 250380 unsigned map_generation = c->map_generation;
781
782 250380 cmpf = c->me_cmp[size];
783 250380 chroma_cmpf = c->me_cmp[size + 1];
784
785
2/2
✓ Branch 0 taken 778451 times.
✓ Branch 1 taken 250380 times.
 1028831 for(dia_size=1; dia_size<=c->dia_size; dia_size++){
786 int dir, start, end;
787 778451 const int x= best[0];
788 778451 const int y= best[1];
789
790 778451 start= FFMAX(0, y + dia_size - ymax);
791 778451 end = FFMIN(dia_size, xmax - x + 1);
792
2/2
✓ Branch 0 taken 1070476 times.
✓ Branch 1 taken 778451 times.
 1848927 for(dir= start; dir<end; dir++){
793 int d;
794
795 //check(x + dir,y + dia_size - dir,0, a0)
796
2/2
✓ Branch 0 taken 773338 times.
✓ Branch 1 taken 297138 times.
 1070476 CHECK_MV(x + dir , y + dia_size - dir);
797 }
798
799 778451 start= FFMAX(0, x + dia_size - xmax);
800 778451 end = FFMIN(dia_size, y - ymin + 1);
801
2/2
✓ Branch 0 taken 1070500 times.
✓ Branch 1 taken 778451 times.
 1848951 for(dir= start; dir<end; dir++){
802 int d;
803
804 //check(x + dia_size - dir, y - dir,0, a1)
805
2/2
✓ Branch 0 taken 789007 times.
✓ Branch 1 taken 281493 times.
 1070500 CHECK_MV(x + dia_size - dir, y - dir );
806 }
807
808 778451 start= FFMAX(0, -y + dia_size + ymin );
809 778451 end = FFMIN(dia_size, x - xmin + 1);
810
2/2
✓ Branch 0 taken 1070370 times.
✓ Branch 1 taken 778451 times.
 1848821 for(dir= start; dir<end; dir++){
811 int d;
812
813 //check(x - dir,y - dia_size + dir,0, a2)
814
2/2
✓ Branch 0 taken 618998 times.
✓ Branch 1 taken 451372 times.
 1070370 CHECK_MV(x - dir , y - dia_size + dir);
815 }
816
817 778451 start= FFMAX(0, -x + dia_size + xmin );
818 778451 end = FFMIN(dia_size, ymax - y + 1);
819
2/2
✓ Branch 0 taken 1070522 times.
✓ Branch 1 taken 778451 times.
 1848973 for(dir= start; dir<end; dir++){
820 int d;
821
822 //check(x - dia_size + dir, y + dir,0, a3)
823
2/2
✓ Branch 0 taken 662232 times.
✓ Branch 1 taken 408290 times.
 1070522 CHECK_MV(x - dia_size + dir, y + dir );
824 }
825
826
4/4
✓ Branch 0 taken 649738 times.
✓ Branch 1 taken 128713 times.
✓ Branch 2 taken 107281 times.
✓ Branch 3 taken 542457 times.
 778451 if(x!=best[0] || y!=best[1])
827 235994 dia_size=0;
828 }
829 250380 return dmin;
830 }
831
832 5955766 static av_always_inline int diamond_search(MPVEncContext *const s, int *best, int dmin,
833 int src_index, int ref_index, const int penalty_factor,
834 int size, int h, int flags){
835 5955766 MotionEstContext *const c = &s->me;
836
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5955766 times.
 5955766 if(c->dia_size==-1)
837 ✗ return funny_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
838
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5955766 times.
 5955766 else if(c->dia_size<-1)
839 ✗ return sab_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
840
2/2
✓ Branch 0 taken 5705386 times.
✓ Branch 1 taken 250380 times.
 5955766 else if(c->dia_size<2)
841 5705386 return small_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
842
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 250380 times.
 250380 else if(c->dia_size>1024)
843 ✗ return full_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
844
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 250380 times.
 250380 else if(c->dia_size>768)
845 ✗ return umh_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
846
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 250380 times.
 250380 else if(c->dia_size>512)
847 ✗ return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, c->dia_size&0xFF);
848
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 250380 times.
 250380 else if(c->dia_size>256)
849 ✗ return l2s_dia_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
850 else
851 250380 return var_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
852 }
853
854 /**
855 @param P a list of candidate mvs to check before starting the
856 iterative search. If one of the candidates is close to the optimal mv, then
857 it takes fewer iterations. And it increases the chance that we find the
858 optimal mv.
859 */
860 3698003 static av_always_inline int epzs_motion_search_internal(MPVEncContext *const s, int *mx_ptr, int *my_ptr,
861 int P[10][2], int src_index, int ref_index, const int16_t (*last_mv)[2],
862 int ref_mv_scale, int flags, int size, int h)
863 {
864 3698003 MotionEstContext *const c = &s->me;
865 3698003 int best[2]={0, 0}; /**< x and y coordinates of the best motion vector.
866 i.e. the difference between the position of the
867 block currently being encoded and the position of
868 the block chosen to predict it from. */
869 int d; ///< the score (cmp + penalty) of any given mv
870 int dmin; /**< the best value of d, i.e. the score
871 corresponding to the mv stored in best[]. */
872 unsigned map_generation;
873 int penalty_factor;
874 3698003 const int ref_mv_stride= s->c.mb_stride; //pass as arg FIXME
875 3698003 const int ref_mv_xy = s->c.mb_x + s->c.mb_y * ref_mv_stride; // add to last_mv before passing FIXME
876 me_cmp_func cmpf, chroma_cmpf;
877
878 3698003 LOAD_COMMON
879 3698003 LOAD_COMMON2
880
881
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3698003 times.
 3698003 if(c->pre_pass){
882 ✗ penalty_factor= c->pre_penalty_factor;
883 ✗ cmpf = c->me_pre_cmp[size];
884 ✗ chroma_cmpf = c->me_pre_cmp[size + 1];
885 }else{
886 3698003 penalty_factor= c->penalty_factor;
887 3698003 cmpf = c->me_cmp[size];
888 3698003 chroma_cmpf = c->me_cmp[size + 1];
889 }
890
891 3698003 map_generation= update_map_generation(c);
892
893 av_assert2(cmpf);
894 3698003 dmin= cmp(s, 0, 0, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
895 3698003 map[0]= map_generation;
896 3698003 score_map[0]= dmin;
897
898 //FIXME precalc first term below?
899
4/4
✓ Branch 0 taken 973945 times.
✓ Branch 1 taken 2724058 times.
✓ Branch 2 taken 180127 times.
✓ Branch 3 taken 793818 times.
 3698003 if ((s->c.pict_type == AV_PICTURE_TYPE_B && !(c->flags & FLAG_DIRECT)) ||
900
2/2
✓ Branch 0 taken 138893 times.
✓ Branch 1 taken 2765292 times.
 2904185 s->mpv_flags & FF_MPV_FLAG_MV0)
901 932711 dmin += (mv_penalty[pred_x] + mv_penalty[pred_y])*penalty_factor;
902
903 /* first line */
904
2/2
✓ Branch 0 taken 234476 times.
✓ Branch 1 taken 3463527 times.
 3698003 if (s->c.first_slice_line) {
905
2/2
✓ Branch 0 taken 186610 times.
✓ Branch 1 taken 47866 times.
 234476 CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
906
2/2
✓ Branch 0 taken 126225 times.
✓ Branch 1 taken 108251 times.
 234476 CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
907 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
908 }else{
909
2/2
✓ Branch 0 taken 168441 times.
✓ Branch 1 taken 3295086 times.
 3463527 if (dmin < ((h * h * c->avctx->mv0_threshold) >> 8)
910 168441 && ( P_LEFT[0] |P_LEFT[1]
911 168441 |P_TOP[0] |P_TOP[1]
912
2/2
✓ Branch 0 taken 119417 times.
✓ Branch 1 taken 49024 times.
 168441 |P_TOPRIGHT[0]|P_TOPRIGHT[1])==0){
913 119417 *mx_ptr= 0;
914 119417 *my_ptr= 0;
915 119417 c->skip=1;
916 119417 return dmin;
917 }
918
2/2
✓ Branch 0 taken 3038324 times.
✓ Branch 1 taken 305786 times.
 3344110 CHECK_MV( P_MEDIAN[0] >>shift , P_MEDIAN[1] >>shift)
919
2/2
✓ Branch 0 taken 3293989 times.
✓ Branch 1 taken 50121 times.
 3344110 CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift) , (P_MEDIAN[1]>>shift)-1)
920
2/2
✓ Branch 0 taken 3178115 times.
✓ Branch 1 taken 165995 times.
 3344110 CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift) , (P_MEDIAN[1]>>shift)+1)
921
2/2
✓ Branch 0 taken 3229314 times.
✓ Branch 1 taken 114796 times.
 3344110 CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)-1, (P_MEDIAN[1]>>shift) )
922
2/2
✓ Branch 0 taken 3199345 times.
✓ Branch 1 taken 144765 times.
 3344110 CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)+1, (P_MEDIAN[1]>>shift) )
923
2/2
✓ Branch 0 taken 1248805 times.
✓ Branch 1 taken 2095305 times.
 3344110 CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
924 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
925
2/2
✓ Branch 0 taken 723028 times.
✓ Branch 1 taken 2621082 times.
 3344110 CHECK_MV(P_LEFT[0] >>shift, P_LEFT[1] >>shift)
926
2/2
✓ Branch 0 taken 352297 times.
✓ Branch 1 taken 2991813 times.
 3344110 CHECK_MV(P_TOP[0] >>shift, P_TOP[1] >>shift)
927
2/2
✓ Branch 0 taken 502653 times.
✓ Branch 1 taken 2841457 times.
 3344110 CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
928 }
929
2/2
✓ Branch 0 taken 2491241 times.
✓ Branch 1 taken 1087345 times.
 3578586 if(dmin>h*h*4){
930
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2491241 times.
 2491241 if(c->pre_pass){
931 ✗ CHECK_CLIPPED_MV((last_mv[ref_mv_xy-1][0]*ref_mv_scale + (1<<15))>>16,
932 (last_mv[ref_mv_xy-1][1]*ref_mv_scale + (1<<15))>>16)
933 ✗ if(!s->c.first_slice_line)
934 ✗ CHECK_CLIPPED_MV((last_mv[ref_mv_xy-ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
935 (last_mv[ref_mv_xy-ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
936 }else{
937
2/2
✓ Branch 0 taken 592933 times.
✓ Branch 1 taken 1898308 times.
 2491241 CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
938 (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
939
2/2
✓ Branch 0 taken 2061555 times.
✓ Branch 1 taken 429686 times.
 2491241 if(s->c.mb_y+1<s->c.end_mb_y) //FIXME replace at least with last_slice_line
940
2/2
✓ Branch 0 taken 534118 times.
✓ Branch 1 taken 1527437 times.
 2061555 CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
941 (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
942 }
943 }
944
945
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3578586 times.
 3578586 if(c->avctx->last_predictor_count){
946 ✗ const int count= c->avctx->last_predictor_count;
947 ✗ const int xstart= FFMAX(0, s->c.mb_x - count);
948 ✗ const int ystart= FFMAX(0, s->c.mb_y - count);
949 ✗ const int xend= FFMIN(s->c.mb_width , s->c.mb_x + count + 1);
950 ✗ const int yend= FFMIN(s->c.mb_height, s->c.mb_y + count + 1);
951 int mb_y;
952
953 ✗ for(mb_y=ystart; mb_y<yend; mb_y++){
954 int mb_x;
955 ✗ for(mb_x=xstart; mb_x<xend; mb_x++){
956 ✗ const int xy= mb_x + 1 + (mb_y + 1)*ref_mv_stride;
957 ✗ int mx= (last_mv[xy][0]*ref_mv_scale + (1<<15))>>16;
958 ✗ int my= (last_mv[xy][1]*ref_mv_scale + (1<<15))>>16;
959
960 ✗ if(mx>xmax || mx<xmin || my>ymax || my<ymin) continue;
961 ✗ CHECK_MV(mx,my)
962 }
963 }
964 }
965
966 //check(best[0],best[1],0, b0)
967 3578586 dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
968
969 //check(best[0],best[1],0, b1)
970 3578586 *mx_ptr= best[0];
971 3578586 *my_ptr= best[1];
972
973 3578586 return dmin;
974 }
975
976 //this function is dedicated to the brain damaged gcc
977 3698003 int ff_epzs_motion_search(MPVEncContext *const s, int *mx_ptr, int *my_ptr,
978 int P[10][2], int src_index, int ref_index,
979 const int16_t (*last_mv)[2], int ref_mv_scale,
980 int size, int h)
981 {
982 3698003 MotionEstContext *const c = &s->me;
983 //FIXME convert other functions in the same way if faster
984
4/6
✓ Branch 0 taken 2862478 times.
✓ Branch 1 taken 835525 times.
✓ Branch 2 taken 2862478 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2862478 times.
✗ Branch 5 not taken.
 3698003 if(c->flags==0 && h==16 && size==0){
985 2862478 return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, 0, 0, 16);
986 // case FLAG_QPEL:
987 // return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, FLAG_QPEL);
988 }else{
989 835525 return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, c->flags, size, h);
990 }
991 }
992
993 2377180 static int epzs_motion_search2(MPVEncContext *const s,
994 int *mx_ptr, int *my_ptr, int P[10][2],
995 int src_index, int ref_index, const int16_t (*last_mv)[2],
996 int ref_mv_scale, const int size)
997 {
998 2377180 MotionEstContext *const c = &s->me;
999 2377180 int best[2]={0, 0};
1000 int d, dmin;
1001 unsigned map_generation;
1002 2377180 const int penalty_factor= c->penalty_factor;
1003 2377180 const int h=8;
1004 2377180 const int ref_mv_stride= s->c.mb_stride;
1005 2377180 const int ref_mv_xy= s->c.mb_x + s->c.mb_y *ref_mv_stride;
1006 me_cmp_func cmpf, chroma_cmpf;
1007 2377180 LOAD_COMMON
1008 2377180 int flags= c->flags;
1009 2377180 LOAD_COMMON2
1010
1011 2377180 cmpf = c->me_cmp[size];
1012 2377180 chroma_cmpf = c->me_cmp[size + 1];
1013
1014 2377180 map_generation= update_map_generation(c);
1015
1016 2377180 dmin = 1000000;
1017
1018 /* first line */
1019
2/2
✓ Branch 0 taken 183836 times.
✓ Branch 1 taken 2193344 times.
 2377180 if (s->c.first_slice_line) {
1020
1/2
✓ Branch 0 taken 183836 times.
✗ Branch 1 not taken.
 183836 CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
1021
2/2
✓ Branch 0 taken 157130 times.
✓ Branch 1 taken 26706 times.
 183836 CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
1022 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1023
2/2
✓ Branch 0 taken 109873 times.
✓ Branch 1 taken 73963 times.
 183836 CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
1024 }else{
1025
1/2
✓ Branch 0 taken 2193344 times.
✗ Branch 1 not taken.
 2193344 CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
1026 //FIXME try some early stop
1027
2/2
✓ Branch 0 taken 1307964 times.
✓ Branch 1 taken 885380 times.
 2193344 CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
1028
2/2
✓ Branch 0 taken 849831 times.
✓ Branch 1 taken 1343513 times.
 2193344 CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
1029
2/2
✓ Branch 0 taken 529303 times.
✓ Branch 1 taken 1664041 times.
 2193344 CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift)
1030
2/2
✓ Branch 0 taken 739770 times.
✓ Branch 1 taken 1453574 times.
 2193344 CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
1031
2/2
✓ Branch 0 taken 1551525 times.
✓ Branch 1 taken 641819 times.
 2193344 CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
1032 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1033 }
1034
2/2
✓ Branch 0 taken 2074156 times.
✓ Branch 1 taken 303024 times.
 2377180 if(dmin>64*4){
1035
2/2
✓ Branch 0 taken 816115 times.
✓ Branch 1 taken 1258041 times.
 2074156 CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
1036 (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
1037
2/2
✓ Branch 0 taken 1908574 times.
✓ Branch 1 taken 165582 times.
 2074156 if(s->c.mb_y+1<s->c.end_mb_y) //FIXME replace at least with last_slice_line
1038
2/2
✓ Branch 0 taken 779110 times.
✓ Branch 1 taken 1129464 times.
 1908574 CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
1039 (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
1040 }
1041
1042 2377180 dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
1043
1044 2377180 *mx_ptr= best[0];
1045 2377180 *my_ptr= best[1];
1046
1047 2377180 return dmin;
1048 }
1049
什么是代理 芭蕉和香蕉有什么区别 员工体检费计入什么科目 日本为什么侵略中国 社会科学院是干什么的
被子什么材质的好 怀孕打黄体酮针有什么作用 伏地魔什么意思 早上嘴苦是什么原因 引狼入室是什么意思
卧底大结局是什么 什么叫环比 低血压高吃什么药 中国人在印度属于什么种姓 掉头发是什么原因男性
胸片能查出什么 腿肚子抽筋是什么原因 什么的琴声 扒灰什么意思 腹主动脉壁钙化是什么意思
孕妇感冒了可以吃什么药hcv8jop2ns3r.cn 弱碱水是什么水hcv9jop7ns9r.cn 奶黄包的馅是什么做的hcv9jop3ns1r.cn 左侧淋巴结肿大是什么原因hcv8jop1ns3r.cn 热量是什么意思hcv7jop7ns0r.cn
唐僧真名叫什么hcv9jop6ns9r.cn 猪蹄和什么一起炖好吃hcv9jop6ns2r.cn 知性是什么意思gangsutong.com 流鼻血看病挂什么科hcv7jop4ns6r.cn 食物不耐受是什么意思hcv8jop0ns5r.cn
电波系是什么意思hcv8jop5ns2r.cn 04年是什么年hcv8jop9ns4r.cn 1月2日是什么星座hcv9jop7ns5r.cn 早晨醒来口苦是什么原因hcv7jop6ns8r.cn 什么叫中出hcv7jop6ns9r.cn
婴儿拉肚子是什么原因造成的hcv9jop1ns9r.cn trance什么意思hcv9jop5ns5r.cn 毒血症是什么病hcv8jop0ns3r.cn 81年五行属什么hcv8jop0ns1r.cn 有妇之夫是什么意思hcv9jop1ns4r.cn
百度