精华内容
下载资源
问答
  • 示例:$(document).ready(function(){ $('.tmplS').hover(function(){ $("..., this).stop().animate({top:'156px', left:'0px'},{queue:false,duration:400}) }, function() { $(".cover", th...
    示例:
    $(document).ready(function(){
    $('.tmplS').hover(function(){
    $(".cover", this).stop().animate({top:'156px', left:'0px'},{queue:false,duration:400})
    }, function() {
    $(".cover", this).stop().animate({top:'0px', left:'0px'},{queue:false,duration:400})
    })
    })
    animate() 方法执行 CSS 属性集的自定义动画。
    该方法通过CSS样式将元素从一个状态改变为另一个状态。CSS属性值是逐渐改变的,这样就可以创建动画效果。
    只有数字值可创建动画(比如 "margin:30px")。字符串值无法创建动画(比如 "background-color:red")。

    语法1:$(selector).animate(styles,speed,easing,callback)

    styles:必需。规定产生动画效果的 CSS 样式和值
    speed:可选。规定动画的速度。默认是 "normal"。
    easing 可选。规定在不同的动画点中设置动画速度的 easing 函数。
    内置的 easing 函数:swing ,linear
    callback 可选。animate 函数执行完之后,要执行的函数。

    语法二:$(selector).animate(styles,options)

    options :可选。规定动画的额外选项。
    可能的值:
    speed - 设置动画的速度
    easing - 规定要使用的 easing 函数
    callback - 规定动画完成之后要执行的函数
    step - 规定动画的每一步完成之后要执行的函数
    queue - 布尔值。指示是否在效果队列中放置动画。如果为 false,则动画将立即开始
    specialEasing - 来自 styles 参数的一个或多个 CSS 属性的映射,以及它们的对应 easing 函数
    展开全文
  • 题目意思很简单,就是给定一个秒数seconds,计算这个seconds的year、day、hour、minute、second,以"1year, 2 days, 1 hour, 1 minute and 2 seconds"这样形式的字符串返回,其中数值为0 的部分不显示,最后一个数值...

    1.题意

    题目链接:https://www.codewars.com/kata/52742f58faf5485cae000b9a

    Your task in order to complete this Kata is to write a function which formats a duration, given as a number of seconds, in a human-friendly way.
    
    The function must accept a non-negative integer. If it is zero, it just returns "now". Otherwise, the duration is expressed as a combination of years, days, hours, minutes and seconds.
    
    It is much easier to understand with an example:
    
    TimeFormatter.formatDuration(62)   //returns "1 minute and 2 seconds"
    TimeFormatter.formatDuration(3662) //returns "1 hour, 1 minute and 2 seconds"
    For the purpose of this Kata, a year is 365 days and a day is 24 hours.
    
    Note that spaces are important.
    
    Detailed rules
    The resulting expression is made of components like 4 seconds, 1 year, etc. In general, a positive integer and one of the valid units of time, separated by a space. The unit of time is used in plural if the integer is greater than 1.
    
    The components are separated by a comma and a space (", "). Except the last component, which is separated by " and ", just like it would be written in English.
    
    A more significant units of time will occur before than a least significant one. Therefore, 1 second and 1 year is not correct, but 1 year and 1 second is.
    
    Different components have different unit of times. So there is not repeated units like in 5 seconds and 1 second.
    
    A component will not appear at all if its value happens to be zero. Hence, 1 minute and 0 seconds is not valid, but it should be just 1 minute.
    
    A unit of time must be used "as much as possible". It means that the function should not return 61 seconds, but 1 minute and 1 second instead. Formally, the duration specified by of a component must not be greater than any valid more significant unit of time.
    

    题目意思很简单,就是给定一个秒数seconds,计算这个seconds的year、day、hour、minute、second,以"1year, 2 days, 1 hour, 1 minute and 2 seconds"这样形式的字符串返回,其中数值为0 的部分不显示,最后一个数值用"and"拼接,如果这个0秒则返回"now"

    2.代码

    一开始想的是算出这些值,然后用if else来进行判断拼接字符串,后来发现需要嵌套的if else太多了,就改为使用一个队列,计算过程中把这些数值对应的字符串按year、day、hour、minute、second的顺序加入到队列中,全部计算完成之后一个一个出队拼接到最终需要返回的字符串中,通过队列的大小来判断当前使用逗号拼接还是用"and"拼接

    import java.util.LinkedList;
    import java.util.Queue;
    
    public class TimeFormatter {  
        public static String formatDuration(int seconds) {
            // your code goes here
            if (seconds == 0) return "now";
    
            int oneMinute = 60;
            int oneHour = 60 * oneMinute;
            int oneDay = 24 * oneHour;
            int oneYear = 365 * oneDay;
    
    		// 注意这里不要用PriorityQueue,因为它是会自动给你排序的,用LinkedList,它也是一个队列
            Queue<String> queue = new LinkedList<>();
    
            String result = "";
            int year = seconds / oneYear;
            if (year == 1) queue.add(year + " year"); else if (year > 1) queue.add(year + " years");
            seconds = seconds - year * oneYear;
    
            int day =  seconds / oneDay;
            if (day == 1) queue.add(day + " day"); else if (day > 1) queue.add(day + " days");
            seconds = seconds - day * oneDay;
    
            int hour = seconds / oneHour;
            if (hour == 1) queue.add(hour + " hour"); else if (hour > 1) queue.add(hour + " hours");
            seconds = seconds - hour * oneHour;
    
            int minute = seconds / oneMinute;
            if (minute == 1) queue.add(minute + " minute"); else if (minute > 1) queue.add(minute + " minutes");
            seconds = seconds - minute * oneMinute;
    
            if (seconds == 1) queue.add(seconds + " second"); else if (seconds > 1) queue.add(seconds + " seconds");
    
            StringBuilder stringBuilder = new StringBuilder();
    
            while (!queue.isEmpty()){
                String tmp = queue.poll();
                stringBuilder.append(tmp);
                if (queue.size() > 1){
                    stringBuilder.append(", ");
                }else if (queue.size() == 1){
                    stringBuilder.append(" and ");
                }
            }
    
            return stringBuilder.toString();
        }
    }
    

    测试用例

    import org.junit.Test;
    import static org.junit.Assert.*;
    
    public class TimeFormatterTest {
        @Test
        public void testFormatDurationExamples() {
            // Example Test Cases
            assertEquals("1 second", TimeFormatter.formatDuration(1));
            assertEquals("1 minute and 2 seconds", TimeFormatter.formatDuration(62));
            assertEquals("2 minutes", TimeFormatter.formatDuration(120));
            assertEquals("1 hour", TimeFormatter.formatDuration(3600));
            assertEquals("1 hour, 1 minute and 2 seconds", TimeFormatter.formatDuration(3662));
            assertEquals("1 hour and 1 second", TimeFormatter.formatDuration(3601));
        }
    }
    
    

    另外,有人给出了一种很简洁的Python写法,使用了if else表达式,具体可以参考https://segmentfault.com/a/1190000006704096

    展开全文
  • 因为编码器的码率控制是以时间s为单位的,比如1000kbps,意思是1s有1000kbits的数据量,然后在编码器中并没有时间的概念, 只有时间基准和时间戳,这两个合并可以计算出来时间,所以编码器的码率控制都是以这两个...

    在编码器中,码率控制有两个重要的参数,1 时间基准 2 当前帧时间戳

    一 为什么需要这两个

    因为编码器的码率控制是以时间s为单位的,比如1000kbps,意思是1s有1000kbits的数据量,然后在编码器中并没有时间的概念,

    只有时间基准和时间戳,这两个合并可以计算出来时间,所以编码器的码率控制都是以这两个参数为基础计算出来的。

     

    时间基准:很多编码器设置的都是1/fps, 但是也有时候需要直接传入ms

    为单位的帧pts,这样的话,时间基准就需要设置为1/1000, 还有如果像ts/mp4格式解码出来的视频帧,时间基准是1/90000,这样编码

    的时候就设置成1/90000。

    时间戳:当时间基准为1/fps时, 时间戳每次+1,依次递增,这样编码出来的帧之后,需要把时间戳scale为容器(flv,rtmp,mp4, ts等)需要的基准。

    看下x264编码器中时间戳在码率控制中的作用。以下分析代码:

    enum pic_struct_e

    {

    PIC_STRUCT_AUTO = 0, // automatically decide (default)

    PIC_STRUCT_PROGRESSIVE = 1, // progressive frame

    // "TOP" and "BOTTOM" are not supported in x264 (PAFF only)

    PIC_STRUCT_TOP_BOTTOM = 4, // top field followed by bottom

    PIC_STRUCT_BOTTOM_TOP = 5, // bottom field followed by top

    PIC_STRUCT_TOP_BOTTOM_TOP = 6, // top field, bottom field, top field repeated

    PIC_STRUCT_BOTTOM_TOP_BOTTOM = 7, // bottom field, top field, bottom field repeated

    PIC_STRUCT_DOUBLE = 8, // double frame

    PIC_STRUCT_TRIPLE = 9, // triple frame

    };

    这个枚举标示了一个帧需要占用多少个时间基准单元,这种是在设置的时间基准为1/fps,并且关闭了b_vfr_input的时候使用的。

    b_vfr_input意思是变动帧率输入,这样编码器计算帧之间的duration, 直接用前后帧时间戳相减。见代码

    h->lookahead->next.list[i]->i_duration = 2 * (h->lookahead->next.list[i+1]->i_pts - h->lookahead->next.list[i]->i_pts);

    当b_vfr_input关闭的时候,时间基准需要被设置为1/fps, 要不然无法计算出帧duration。见代码

    h->lookahead->next.list[i]->i_duration = delta_tfi_divisor[h->lookahead->next.list[i]->i_pic_struct];

    delta_tfi_divisor是一个数组,预先设定了,某种类型的帧,duration为多少个时间基准单元。

    接下来计算得到时间基准之后,开始用于码率控制。以crf码控为例

    clip_qscale 为x264编码器中主要的帧级别的码控函数

    double fenc_cpb_duration = (double)h->fenc->i_cpb_duration *
                h->sps->vui.i_num_units_in_tick / h->sps->vui.i_time_scale;

    首先根据时间基准把duration换算成以秒为单位的时间。

    total_duration += last_duration; //累加到当前编码帧的duration中,得到当前编码的总帧的duration,

    通过总的编码帧duration以及

    for( int j = 0; buffer_fill_cur >= 0 && buffer_fill_cur <= rcc->buffer_size; j++ )
    {//先通过当前给定的qp值计算出来,需要消耗多少bits
     total_duration += last_duration;
    buffer_fill_cur += rcc->vbv_max_rate * last_duration;
     int i_type = h->fenc->i_planned_type[j];
     int i_satd = h->fenc->i_planned_satd[j];
    if( i_type == X264_TYPE_AUTO )
     break;
     i_type = IS_X264_TYPE_I( i_type ) ? SLICE_TYPE_I : IS_X264_TYPE_B( i_type ) ? SLICE_TYPE_B : SLICE_TYPE_P;
     cur_bits = predict_size( &rcc->pred[i_type], frame_q[i_type], i_satd );
    buffer_fill_cur -= cur_bits;
    last_duration = h->fenc->f_planned_cpb_duration[j];
    }

    然后按照当前的vbv码率控制给的参数计算出来,total_duration时长的帧最多能消耗多少bits

    target_fill = X264_MIN( rcc->buffer_fill + total_duration * rcc->vbv_max_rate * 0.5, rcc->buffer_size * 0.5 ); 

    然后比较这两,如果不足,就调大qp值。 qp的默认值为crf值

    if( buffer_fill_cur < target_fill )
    {
      q *= 1.01;
      terminate |= 1;
     continue;
     }

    //VBV码率控制buf的限制,和上面的maxrate控制类似

    target_fill = x264_clip3f( rcc->buffer_fill - total_duration * rcc->vbv_max_rate * 0.5, rcc->buffer_size * 0.8, rcc->buffer_size );
    if( rcc->b_vbv_min_rate && buffer_fill_cur > target_fill )
     {
     q /= 1.01;
    terminate |= 2;
     continue;
     }

    最多调整1000次,最终得到一个合适的qp值。

    展开全文
  • chrono是一个模版库,包含了...std::chrono::duration 和字面意思一样,表示一段时间,原型是一个模板类: template< class Rep, class Period = std::ratio<1> > class duration;1234 Rep...

    chrono是一个模版库,包含了一系列时间相关功能。

     

    duration

     

    std::chrono::duration 和字面意思一样,表示一段时间,原型是一个模板类:

     

     

     

    template<
        class Rep,
        class Period = std::ratio<1>
    > class duration;1234

     

    Rep表示一种数值类型,用来表示Period的数量,比如int、float。
    Period是ratio类型,代表用秒表示的时间单位,默认为std::ratio<1> ,std::ratio代表一个分数,如下代码,N是分子,D是分母。

     

     

     

    template <intmax_t N, intmax_t D = 1> struct ratio;1

     

    Period是std::ratio<1>时,说明分数为1/1,也就是1秒。

     

    在chrono中预定义了一系列的duration:

     

     

     

    typedef duration<long long, nano> nanoseconds;
    typedef duration<long long, micro> microseconds;
    typedef duration<long long, milli> milliseconds;
    typedef duration<long long> seconds;
    typedef duration<int, ratio<60> > minutes;
    typedef duration<int, ratio<3600> > hours;123456

     

    以seconds为例,Period为std::ratio<1>代表1s,std::chrono::seconds(10)就代表10秒。
    以minutes为例,Period为std::ratio<60>代表60s,std::chrono::minutes(10)就代表10分钟。
    以milliseconds为例,Period为milli(typedef ratio<1, 1000>)代表1/1000s,std::chrono::minutes(10)就代表10毫秒。

     

    duration对象常用于std::this_thread::sleep_for、std::timed_mutex::try_lock_for等函数,作为入参:

     

     

     

    std::this_thread::sleep_for(std::chrono::seconds(10));  // 等待10s1

     

    另外,C++11还提供了duration之间的类型转换duration_cast,用于不同时间精度间的装换:

     

     

     

    #include <iostream>
    #include <chrono>

     

    int main()
    {
        std::chrono::seconds scd(10);
        std::cout << scd.count() << std::endl;   // 10
        std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(scd).count() << std::endl;     // 10000

     

        return 0;
    }

     

    // 精度高转换成精度低的时候会导致精度丢失,需要注意
    #include <iostream>
    #include <chrono>

     

    int main()
    {
        std::chrono::milliseconds scd(10001);
        std::cout << scd.count() << std::endl;      // 10001
        std::cout << std::chrono::duration_cast<std::chrono::seconds>(scd).count() << std::endl;                     // 10

     

        return 0;
    }
    12345678910111213141516171819202122232425

     

    time_point

     

    std::chrono::time_point用于表示一个时间点,需要为时间点指定参考时钟(clock,clock类需要满足指定要求,详见https://zh.cppreference.com/w/cpp/named_req/Clock)和相对于参考时钟步进值。它被实现成如同存储一个 Duration 类型的自 Clock 的纪元起始开始的时间间隔的值。

     

     

     

    template
    <class Clock, class Duration = typename Clock::duration>
    class time_point;123

     

    例如以下代码,其中system_clock::time_point被定义为time_point,system_clock是C++11实现的clock类(一般是从格林威治标准时间开始),此处作为time_point模板的第一个类型,第二个类型Clock::duration被定义为microseconds,也就是说time_point表示从格林威治标准时间(1970-01-01 00:00:00.000)开始到指定时间的毫秒数。

     

     

     

    #include <iostream>
    #include <chrono>
    using namespace std::chrono;

     

    int main()
    {
        system_clock::time_point now = system_clock::now();  // now表示当前时间到格林威治标准时间的毫秒数
        //等效于time_point<system_clock> now = system_clock::now();

     

        std::cout << now.time_since_epoch().count() << std::endl;  // 1534602834436896
        return 0;
    }123456789101112

     

    time_point对象常用于std::this_thread::sleep_until、std::timed_mutex::try_lock_until等函数,作为入参:

     

     

     

    #include <iostream>
    #include <chrono>
    #include <thread>
    using namespace std::chrono;

     

    int main()
    {
        system_clock::time_point until = system_clock::now();
        until += seconds(5);
        std::this_thread::sleep_until(until);   // 一直等待到当前时间加上5s之后的时间点

     

        return 0;
    }12345678910111213

     

    同样,time_point也支持精度装换time_point_cast:

     

     

     

    #include <iostream>
    #include <chrono>
    using namespace std::chrono;

     

    int main()
    {
        time_point<system_clock> now = system_clock::now();
        std::cout << now.time_since_epoch().count() << std::endl;  // 毫秒级

     

        time_point<system_clock, hours> hour_now =
            time_point_cast<hours>(system_clock::now());
        std::cout << hour_now.time_since_epoch().count() << std::endl;   // 小时级

     

        return 0;
    }123456789101112131415

     

    clock

     

    C++11新增了时钟的概念,时钟 (Clock) 概念描述由 std::chrono::duration 、 std::chrono::time_point 和获取当前 time_point 的函数 now() 组成的一束内容,将时钟的 time_point 原点定为时钟的纪元。C++11中有三种时钟:system_clock,steady_clock和high_resolution_clock。

     

    system_clock表示本地系统的时钟,因此是不稳定的,因为有可能被修改,上文已经举例了一些它的用法,下面再列举一个常用的显示当前系统时间的用法:

     

     

     

    #include <iostream>
    #include <chrono>
    #include <ctime>
    #include <iomanip>
    using namespace std::chrono;

     

    int main()
    {
        time_point<system_clock> now = system_clock::now();
        time_t t_now = system_clock::to_time_t(now);
        tm* tm_now = std::localtime(&t_now);
        std::cout << std::put_time(tm_now, "%Y-%m-%d %H:%M:%S") << std::endl;

     

        return 0;
    }123456789101112131415

     

    steady_clock表示稳定的时间间隔,后一次调用now()得到的时间总是比前一次的值大(如果中途修改了系统时间,也不影响now()的结果),所以通常用来计算时间间隔:

     

     

     

    #include <iostream>
    #include <chrono>
    #include <thread>
    using namespace std::chrono;

     

    int main()
    {
        time_point<steady_clock> begin_time = steady_clock::now();
        std::this_thread::sleep_for(milliseconds(10));
        time_point<steady_clock> end_time = steady_clock::now();

     

        // steady_clock的精度为纳秒,装换成毫秒输出
        std::cout << duration_cast<milliseconds>(end_time - begin_time).count() << std::endl;

     

        getchar();
        return 0;
    }1234567891011121314151617

     

    high_resolution_clock 表示实现提供的拥有最小计次周期的时钟,它可以是system_clock或steady_clock的别名,或第三个独立时钟。在我的实验的机器中被定义为:

    typedef steady_clock high_resolution_clock;
    ---------------------
    作者:WizardtoH
    原文:https://blog.csdn.net/WizardtoH/article/details/81738682
     

    展开全文
  • springboot session超时时间

    千次阅读 2019-02-16 11:30:10
    springboot1.0为 server.session.timeout= springboot2.0为 server.servlet.session.timeout= 我用的springboot2   ...要求的参数是Duration ...点开Duration ...意思为 基于时间的时间量 这个类...
  • 第一段是初始化贝塞尔曲线,第二段是什么意思 ``` void ActionBezierBy::InitWithTarget(RealObjectPtr target, float duration, const ccBezierConfig& c) { ActionBase::InitWithTarget(target,duration)...
  • 债券中的久期是什么意思

    千次阅读 2019-09-19 10:53:46
    久期(Duration),又称为“持续期”,解释有: 是一个很好的衡量债券现金流的指标 考量债券时间维度的风险,回收现金流的时间加权平均 衡量债券价格对基础利率将变化敏感程度的指标 以现金流现值为权重的平均到期...
  • %@ OutputCache Duration="3" VaryByParam="*" %>以前不知道那个*号是什么意思,今天无意间查了帮助,原来这个参数是代表无论以post还是get提交,都会清楚缓存帮助详细内容如下:VaryByParam分号分隔的字符串...
  • <p>To my surprise, this compiled <pre><code>fmt.Println(time.Second * time....<p>It doesn't make any sense to multiply a duration by duration and get another duration. <p>What's going on? </div>
  • <p>I'm reading the code that package <code>time, and then I want to know how the <code>func After(d Duration) <-chan Time</code> works. <p>I found the code follows: <pre><code>func After(d ...
  • cookie:流表规则标示duration:流表项创建持续的时间(单位:S)table:流表所属的table编号n_packets:流表项匹配到的报文数n_bytes:此流表项匹配到的字节数idle_age:此流表项从最后一个匹配的报文到现在空闲的...
  • 可悲了,写了这么多年,第一次看到这个代码。 SELECT [owt].[session_id], [owt].[exec_context_... [owt].[wait_duration_ms], [owt].[wait_type], [owt].[blocking_session_id], [owt].[resource_des...
  • android:duration 动画持续时间,以毫秒为单位 android:fillAfter 如果设置为true,控件动画结束时,将保持动画最后时的状态android:fillBefore 如果设置为true,控件动画结束时,还原到开始动画前的状态an
  • &lt;translate xmlns:android="... android:duration="300" android:fromXDelta="100%" android:fromYDelta="0" android:toXDelta="0" android:toYDe..
  • let timeDifference = Math.min(nowTime - startTime,duration) for (let attr in options) { let result = start[attr] + range[attr] / duration * timeDifference ele.style[attr] = result + 'px' } ...
  • 现在就来讲讲Animation里这四个标签的属性。...android:duration 动画持续时间,以毫秒为单位 android:fillAfter 如果设置为true,控件动画结束时,将保持动画最后时的状态android:fillBefore 如果
  • 对CSS3 Animation,相信大家都不陌生了,其有八大属性:animation-name:动画名称animation-duration:规定完成一个周期所花费的时间(秒或毫秒)animation-delay:定义动画开始前等待的时间,以秒或毫秒计。...
  • ID",T0."ALBUMID",T0."PHOTOID" , T."_ID",T."SYSID",T."FILENAME",T."FILEPATH",T."FILESIZE",T."FILETYPE",T."MODIFIEDTIME",T."SHOOTTIME",T."WIDTH",T."HEIGHT",T."LONGITUDE",T."LATITUDE",T."DURATION",...
  • How can the samples count be shown as time duration? <p>What’s more, I even ever got such output shows that the sample time is bigger than wall time, how could it be such result? <p><code>Duration...
  • <p>func AfterFunc(d Duration, f func()) *Timer AfterFunc 会等待 d 时长后调用 f 函数,这里的 f 函数将在另外一个 goroutine 中执行。Leaf 提供了一个相同的 AfterFunc 函数,相比之下,f ...
  • Duration Pre-request script History entries can be sorted by any fields Histories can be deleted one-by-one or all together Collections: Keep your API requests organized with collections and folders...
  • 就是有一个表单,表单里面有一个叫做Duration的字段, 这个字段目前是一个input输入框,想要改成可以选择的,并且可以输入的下拉框. 其实当初我是不想接的,因为目前团队只有我一个前端,所有大活小活都是我再做,而且还有...
  • Await.result(f,Duration.create(5, TimeUnit.SECONDS))表示什么意思
  • 关于定时器

    2020-08-14 10:32:48
    原来人家这儿用的是duration,而duration其实是int64,貌似是统一的意思呢。 再看一下各个时间单位,如下: 原来所有的单位最后都是转换到duration上的,一个duration其实是一个纳秒。 所以,不管你时间
  • MySQL的去重复优化

    2018-10-29 14:03:49
    mysql workbench中fetch和duration分别是什么意思 fetch: 它是指SQL在网络传输的过程中所用的时间,但不是SQL执行的时间 duration: 它指的是SQL语句执行的时间 下面有三种不同的SQL语句,最终的查询结果是一样的,...
  • 动画的第一个属性 transform: (使…变化) 它的常见属性值分别是 scale 缩放的意思 rotate 旋转的意思 translate 位移的意思 skew 倾斜的意思(不...transition-duration:1s; 第一个值 意为过度时间 transition-delay
  • golang编程之定时器

    2018-08-02 10:49:08
     1)func AfterFunc(d Duration, f func()) *Timer这方法大概意思是经过d时间间隔,就执行f函数。  2)func NewTimer(d Duration) *Timer这函数打个意思是创建一个timer每过去d时间间隔就发送当前...
  • oracle问题:v_run_duration:=round((sysdate-v...这是什么意思 v_run_duration这个变量赋值,等于sysdate-v_sysdate的差把并转成秒,如sysdate=2012-7-3,v_sysdate=2012-7-2,那v_run_duration=round(('2012-7-3'-'2012-7
  • librosa库一些函数新用法

    千次阅读 2019-10-31 17:11:16
    之前用函数也就是会用一个形参就行了,没想到librosa还有很多方便的方法, 比如这个玩意: filename = librosa.util.example_audio_file() ...意思人家也给了,就是从15秒位置处加载5秒,好厉害啊。 duration...

空空如也

空空如也

1 2 3 4 5 6
收藏数 107
精华内容 42
关键字:

duration意思