日历

« 2008-10-08  
日 一 二 三 四 五 六
   1234
567891011
12131415161718
19202122232425
262728293031 

最新来客

统计信息

  • 访问量: 1991
  • 日志数: 24
  • 图片数: 3
  • 建立时间: 2006-12-11
  • 更新时间: 2008-10-06

RSS订阅

我的最新日志

  • 代码覆盖率分析（gcov）(转)

    2008-8-11

    为什么需要代码覆盖率分析？

    在发布代码的时候，我们常常会对其进行一系列的测试来协调软件的性能和功能，使他们和预计的相同。但是检验通常都是相当的困难，即使程序相当的简单。开发者常常会借助一些测试工具（test suite)来模拟或者重建执行脚本。如果测试程序组是彻底的，那么程序的各个功能都将被测试到并且都可以证明是可以工作的。

    但是怎样才算彻底呢？简单点说就是测试程序的每一条路径，验证每一个结果，执行每一条语句，证明没一句语句是没用的。gcov就是一个用来检验你的每一句语句是否都执行了的工具。

    什么是代码覆盖率分析？
    代码覆盖率分析就是找到定位没用的或者不执行的代码的过程。没用的代码不会存在什么问题，但是他们会影响程序的可读性；不执行的代码则可能是未来bug的所在。所以找到他们，把他们从你的程序中移处是大有裨益的。
    覆盖率分析主要有下面的几个过程：
        通过测试程序组找到不执行的程序段；
        添加额外测试程序组，以便增加代码覆盖率；
        决定代码覆盖率的定量测度，他也是程序质量的间接测度。

    代码覆盖率分析的缺陷
    代码覆盖率分析不能找出程序的逻辑错误。考虑一下下面的代码
    10:  rc = call_to_xx ();
    11:  if (rc == ERROR_FATAL)
    12:    exit(2);    /* exit with error code 2 */
    13:  else
    14:    /* continue on */
    当测试程序段运行到11行时，11行始终都不能为真。call_to_xx返回了另外的一个错误比如ERROR_HANDLE，除非我们加入这种错误的处理方式的代码。
    代码覆盖测试工具不会告诉你什么是必须的，他们只能显示已经存在的代码的覆盖率。

    代码覆盖率的类型
    gcov可以用来测量各种形式的代码覆盖率。最常见最有用的两种是分支覆盖（branch coverage)和循环覆盖（loop coverage）
    分支覆盖证明各个方向的每一条分支都被执行到了。循环覆盖试图证明循环内部的每一条路径都被测试到了。循环覆盖似乎非常的复杂，但基本上只要满足下面的三个状况，就可以作了。
        1。循环条件不满足，循环没有内部没有执行；
        2。循环条件就满足了一次，循环内部就执行了一次；
        3。循环条件至少满足了两次，循环至少执行了两次。
    举个例子
    void  function(int number)
    {
      if (number % 2) == 0)
        printf("even \n");
      for (;number < 9; number++){
        printf("number is %d\n", number);
      }
    }

    function(11);   满足状况一
    function(8);    满足状况二
    function(6);    满足状况三   

    代码覆盖率工具gcov的使用
    要使用gcov，需要在我们用gcc编译程序时加入两个参数fprofile-arcs和ftest-coverage.
    fprofile-arcs参数使gcc创建一个程序的流图，之后找到适合图的生成树。只有不在生成树中的弧被操纵（instrumented）：gcc添加了代码来清点这些弧执行的次数。当这段弧是一个块的唯一出口或入口时，操纵工具代码（instrumentation code)将会添加到块中，否则创建一个基础块来包含操纵工具代码。
    gcov主要使用.gcno和.gcda两个文件
    .gcno是由-ftest-coverage产生的，它包含了重建基本块图和相应的块的源码的行号的信息。
    .gcda是由加了-fprofile-arcs编译参数的编译后的文件运行所产生的，它包含了弧跳变的次数和其他的概要信息。

    下面是一个简要的范例：
      1 #include <stdlib.h>
      2 #include <stdio.h>
      3
      4 int main(int argc,char** argv)
      5 {
      6     int x,y;
      7     int arraysize;
      8     int **array;
      9
     10     if(argc!=2)
     11     {
     12         printf("Usage: %s Enter arraysize value\n;",argv[0]);
     13         exit(-1);
     14     }
     15     else
     16     {
     17         arraysize = atoi(argv[1]);
     18         if(arraysize <=0)
     19         {
     20             printf("Array size must be larger than 0\n;");
     21             exit(-1);
     22         }
     23     }
     24
     25     array = (int**) malloc( arraysize*sizeof(int*));
     26
     27     printf("Creating an %d by %d array \n",arraysize,arraysize);
     28
     29     if(array == NULL)
     30     {
     31         printf("Malloc failed for array size %d \n",arraysize);
     32         exit(-1);
     33     }
     34
     35     for (x=0;x<arraysize;x++)
     36     {
     37         array[x] = (int*) malloc (arraysize*sizeof(int));
     38
     39         if(array[x] == NULL)
     40         {
     41             printf("Failed malloc for array size %d\n",arraysize);
     42             exit(-1);
     43         }
     44     }
     45
     46     exit(0);
     47 }

    $ gcc -fprofile-arcs -ftest-coverage -g -o sample test.c
    $ ./sample 10
    Creating an 10 by 10 array
     $ gcov test.c
    File ''/usr/include/sys/sysmacros.h''
    Lines executed:0.00% of 6
    /usr/include/sys/sysmacros.h:creating ''sysmacros.h.gcov''

    File ''test.c''
    Lines executed:57.89% of 19
    test.c:creating ''test.c.gcov''
    $ cat test.c.gcov
            -:    0:Source:test.c
            -:    0:Graph:test.gcno
            -:    0:Data:test.gcda
            -:    0:Runs:1
            -:    0:Programs:1

    -:    1:#include <stdlib.h>
            -:    2:#include <stdio.h>
            -:    3:
            -:    4:int main(int argc,char** argv)
            1:    5:{
            -:    6:        int x,y;
            -:    7:        int arraysize;
            -:    8:        int **array;
            -:    9:
            1:   10:        if(argc!=2)
            -:   11:        {
        #####:   12:                printf("Usage: %s Enter arraysize value;\n",argv[0]);
        #####:   13:                exit(-1);
            -:   14:        }
            -:   15:        else
            -:   16:        {
            1:   17:                arraysize = atoi(argv[1]);
            1:   18:                if(arraysize <=0)
            -:   19:                {
        #####:   20:                        printf("Array size must be larger than 0;\n");
        #####:   21:                        exit(-1);
            -:   22:                }
            -:   23:        }
            -:   24:
            1:   25:        array = (int**) malloc( arraysize*sizeof(int*));
            -:   26:
            1:   27:        printf("Creating an %d by %d array \n",arraysize,arraysize);
            -:   28:
            1:   29:        if(array == NULL)
            -:   30:        {
        #####:   31:                printf("Malloc failed for array size %d \n",arraysize);
        #####:   32:                exit(-1);
            -:   33:        }
            -:   34:
           11:   35:        for (x=0;x<arraysize;x++)
            -:   36:        {
           10:   37:                array[x] = (int*) malloc (arraysize*sizeof(int));
            -:   38:
           10:   39:                if(array[x] == NULL)
            -:   40:                {
        #####:   41:                        printf("Failed malloc for array size %d\n",arraysize);
        #####:   42:                        exit(-1);
            -:   43:                }
            -:   44:        }
            -:   45:
            1:   46:&n
         

    bsp;       exit(0);
            -:   47:}

    正如我们看到的,我们现在的覆盖率是57.89%，#####后面的语句是现在没有够执行到的。

    $ ./sample
    Usage: ./sample Enter arraysize value;
    $ gcov test.c
    File ''/usr/include/sys/sysmacros.h''
    Lines executed:0.00% of 6
    /usr/include/sys/sysmacros.h:creating ''sysmacros.h.gcov''

    File ''test.c''
    Lines executed:68.42% of 19
    test.c:creating ''test.c.gcov''
    现在运行了没有参数的情况，这种情况占了10.53%(68.42-57.89)

    $ ./sample 0
    Array size must be larger than 0;
    $ gcov test.c
    File ''/usr/include/sys/sysmacros.h''
    Lines executed:0.00% of 6
    /usr/include/sys/sysmacros.h:creating ''sysmacros.h.gcov''

    File ''test.c''
    Lines executed:78.95% of 19
    test.c:creating ''test.c.gcov''
    有测试了一种情况，那就是arraysize=0现在的覆盖率已经达到了78.95%

    还有两种情况，那就是二维数组的第一维和第二维内存空间的申请了。在现在的状况下，malloc()不太可能分配失败，所以我们借助工具gdb来模拟malloc失败时的情况。
    $ gdb sample
    GNU gdb Red Hat Linux (6.6-16.fc7rh)
    Copyright (C) 2006 Free Software Foundation, Inc.
    GDB is free software, covered by the GNU General Public License, and you are
    welcome to change it and/or distribute copies of it under certain conditions.
    Type "show copying" to see the conditions.
    There is absolutely no warranty for GDB.  Type "show warranty" for details.
    This GDB was configured as "i386-redhat-linux-gnu"...
    Using host libthread_db library "/lib/libthread_db.so.1".
    (gdb) l
    1       #include <stdlib.h>
    2       #include <stdio.h>
    3
    4       int main(int argc,char** argv)
    5       {
    6               int x,y;
    7               int arraysize;
    8               int **array;
    9
    10              if(argc!=2)
    (gdb) l
    11              {
    12                      printf("Usage: %s Enter arraysize value\n;",argv[0]);
    13                      exit(-1);
    14              }
    15              else
    16              {
    17                      arraysize = atoi(argv[1]);
    18                      if(arraysize <=0)
    19                      {
    20                              printf("Array size must be larger than 0\n;");
    (gdb) l
    21                              exit(-1);
    22                      }
    23              }
    24
    25              array = (int**) malloc( arraysize*sizeof(int*));
    26
    27              printf("Creating an %d by %d array \n",arraysize,arraysize);
    28
    29              if(array == NULL)
    30              {
    (gdb) b 29
    Breakpoint 1 at 0x8048ada: file test.c, line 29.
    (gdb) r 10
    Starting program: /home/secularbird/Templates/test/sample 10
    Creating an 10 by 10 array

    Breakpoint 1, main (argc=2, argv=0xbf9b59f4) at test.c:29
    29              if(array == NULL)
    (gdb) print array
    $1 = (int **) 0x90af008
    (gdb) set array=0
    (gdb) print array
    $2 = (int **) 0x0
    (gdb) step
    31                      printf("Malloc failed for array size %d \n",arraysize);
    (gdb) cont
    Continuing.
    Malloc failed for array size 10

    Program exited with code 0377.
    (gdb) quit
    l命令是list的简写，显示了程序的源代码。
    b 29是在29行设置一个断点，之所以这样设置是因为array空间申请过了，我们为了模拟需要改变它的值。
    r 10是run 10，也就是运行程序，10是传递的命令行参数。
    print array打印array的地址
    set array=0将array指向空地址
    step一步一步的运行程序，简写是s
    cont继续运行程序
    quit退出gdb。

    接下来做类似的工作产生另一个malloc fail。
    $ gdb sample
    GNU gdb Red Hat Linux (6.6-16.fc7rh)
    Copyright (C) 2006 Free Software Foundation, Inc.
    GDB is free software, covered by the GNU General Public License, and you are
    welcome to change it and/or distribute copies of it under certain conditions.
    Type "sh ow copying" to see the conditions.
    There is absolutely no warranty for GDB.  Type "show warranty" for details.
    This GDB was configured as "i386-redhat-linux-gnu"...
    Using host libthread_db library "/lib/libthread_db.so.1".
    (gdb) l
    1       #include <stdlib.h>
    2       #include <stdio.h>
    3
    4       int main(int argc,char** argv)
    5       {
    6               int x,y;
    7               int arraysize;
    8               int **array;
    9
    10              if(argc!=2)
    (gdb) l
    11              {
    12                      printf("Usage: %s Enter arraysize value\n;",argv[0]);
    13                      exit(-1);
    14              }
    15              else
    16              {
    17                      arraysize = atoi(argv[1]);
    18                      if(arraysize <=0)
    19                      {
    20                              printf("Array size must be larger than 0\n;");
    (gdb) l
    21                              exit(-1);
    22                      }
    23              }
    24
    25              array = (int**) malloc( arraysize*sizeof(int*));
    26
    27              printf("Creating an %d by %d array \n",arraysize,arraysize);
    28
    29              if(array == NULL)
    30              {
    (gdb) l
    31                      printf("Malloc failed for array size %d \n",arraysize);
    32                      exit(-1);
    33              }
    34
    35              for (x=0;x<arraysize;x++)
    36              {
    37                      array[x] = (int*) malloc (arraysize*sizeof(int));
    38
    39                      if(array[x] == NULL)
    40                      {
    (gdb) b 39
    Breakpoint 1 at 0x8048b7a: file test.c, line 39.
    (gdb) r 10
    Starting program: /home/secularbird/Templates/test/sample 10
    Creating an 10 by 10 array

    Breakpoint 1, main (argc=2, argv=0xbfdcae04) at test.c:39
    39                      if(array[x] == NULL)
    (gdb) print array[0]
    $1 = (int *) 0x9bc2038
    (gdb) set array[0]=0
    (gdb) step
    41                              printf("Failed malloc for array size %d\n",arraysize);
    (gdb) cont
    Continuing.
    Failed malloc for array size 10

    Program exited with code 0377.
    (gdb) quit

    $ gcov test.c
    File ''/usr/include/sys/sysmacros.h''
    Lines executed:0.00% of 6
    /usr/include/sys/sysmacros.h:creating ''sysmacros.h.gcov''

    File ''test.c''
    Lines executed:100.00% of 19
    test.c:creating ''test.c.gcov''
    到现在为止每条路径都测试过了，代码覆盖率也已经达到了100%，也可以查看一下test.c.gcov文件
    里面已经没有#####了。

    参考资料：
    Linux® Debugging and Performance Tuning: Tips and Techniques By Steve Best
    man gcov
    http://gcc.gnu.org/onlinedocs/gcc/Gcov-Data-Files.html#Gcov-Data-Files

    查看(55) 评论(0)

  • H.264简单总结(如霜的天空)(严重参考的是毕厚杰的书)

    2008-7-28

    一、视频信息和信号的特点

    1．1 直观性

           利用人的视觉系统，直接获取视频信息

    1．2 确定性

           视频信息只管具体，不易与其他内容混淆

    1．3 高效性

           利用视觉系统，人们可以并行的观察图像的各个象素，因此具有高效性。

    1．4 广泛性

           视觉系统占外界信息总量的70％

    1．5视频信号的高带宽性

           视频信息包含大量的变化的信息，信息量极大，传输网络所需要的带宽相对较大。

    二、视频压缩的要求和可能性

    2．1视频压缩编码的目标

    由于视频信息量大，传输带宽高，就要求先对视频源压缩，然后传输，以便节约带宽和存储空间。

                    （1）       视频必须压缩在一定的带宽内，要保证足够的压缩比。

                    （2）       视频压缩后，经恢复要保证一定的视频质量

                    （3）       视频编码器的实现方式应力求简单、易实现、低成本、可靠性高。

    2．2视频压缩的可能行

                     （1）时间相关行

                         在一组视频序列中，相邻两帧只有极少的不同之处，这便是时间相关性。

                    （2）空间相关性

                         在同一帧中，相邻象素之间有很大的相关性，两象素越近，侧相关性越强。

    三、视频编码技术

    3．1基本结构

           视频编码方式与采用的信源有关。根据采用的信源的模型，视频编码可以分为两大类：基于波形的编码和基于内容的编码。

    3．2 基于波形的编码

           如果采用“一幅图像由许多象素构成”的信源模型，这种信源模型的参数就是象素的亮度和色度的幅度值，对这些参数进行编码的技术即为基于波形编码。

           利用象素空间的相关性和帧间的时间相关性，采用预测编码和变化编码技术，减少视频信号的相关性，从而显著降低视频序列的码率，实现压缩编码的目标。

    3．3 基于内容的编码

            如果采用一个分量有几个物体构成的信源模型，这种信源模型的参数事各个物体的形状，纹理，运动，对这些参数进行编码的技术就是基于内容的编码。

    四、h264的应用

    4．1 H. 264的技术特点可以归纳为三个方面

    （1）注重实用;

    （2）注重对移动和IP网络的适应;

    （3）在混合编码器的基本框架下，对其主要关键部件都做了重大改进，如多模式运动估计、帧内预测、多帧预测、基于内容的变长编码、4X4二维整数变换等。

    （4）在关注H. 264的优越性能的同时必然需要衡量其实现难度。从总体上说，H. 264性能的改进是以增加复杂性为代价而获得的。据估计，H. 264 编码的计算复杂度大约相当于H. 263的3倍，解码复杂度大约相当于H. 263的2倍.

    4．2 h264应用可分为3个级别:

            (1) 基本档次: (简单版本, 应用面广, 支持帧内和帧间编码, 基于可变程度的熵编码.)

                                     应用领域: 视频会话, 会议电视, 无线通信等实时通信.

             (2) 主要档次: ( 采用了多项提高图像质量和增加压缩比的技术措施, 支持隔行视频, 支持基于上下文的自适应的算术编码.)

                                      应用领域: 数字广播与数字视频存储.

           （3）扩展档次: 应用领域: 可用于各种网络的视频流传输，视频点播

    五、视频编码原理

    5．1基本概念

    （1）视频编码器能够对一个图像或者一个视频序列进行压缩，产生码流。

         

    在上图中，编码器输入的帧或场Fn，以宏块为单位被编码器处理 (图上传不上啊！)。

    如果采用帧间预测编码：其预测值P，是由已编码的图像做参考，经运动补偿得到的。预测图像P和当前帧Fn相减，得到两图像的残差值Dn，Dn在经过转换T，量化Q，去处空间冗余，得到系数X，将X重排（使数据更加紧凑），熵编码（加入运动矢量。一些图像相关得信息），得到nal数据。

    在编码器中有个重构的过程（解码的过程），量化系数X，反量化，反变换，得到Dn’，Dn’和预测图像P相加，得到uFn’,再滤波得到Fn’，Fn’就是Fn编码再解码后得图像。

    如果采用帧内预测编码：预测值P，是由当前片中，己编码的宏块预测得到的（亮度4×4或者16×16预测，色度8×8预测）。当前待处理的块，减去预测值P，得残差值Dn，Dn在经过转换T，量化Q，得到系数X，将X重排（使数据更加紧凑），熵编码，得到nal数据。

    在重构的过程中，量化系数X，反量化，反变换，得到Dn’，Dn’和预测图像P相加得到当前宏块编码解码后得值，该值可以用来做帧内预测的参考宏块。

    编码器要有重构机制的原因：重构过程，实质上是个解码的过程，解码后的图像和源图肯定有差别，我门利用解码后的图像做参考，就能够和解码器中保值一致，就能够提高图像的预测精度。（在解码器中，是利用己解码的图像做参考，是从解码的图像预测出下一副图像）

                  （2）视频解码器： 能够对一个码流解码，产生和源图或源视频序列相近的图像或视频序列。如果解码出的图像和源图是一样的，这个编解码过程是无损的，否则是有损。

                         解码器的实现和编码器的重构机制，是一样的。

                  （3）场 、帧、图像

                         场：隔行扫描的图像，偶数行成为顶场行。奇数行成为底场行。所有顶场行称为顶场。所有底场行称为底场。

                         帧：逐行扫描的图像。

                         图像：场和帧都可认为是图像。

                  （4）宏块、片：

                         宏块：一个宏块由一个16×16亮度块、一个8×8Cb和一个8×8Cr组成。

                         片：一个图像可以划分成一个或多个片，一个片由一个或多个宏块组成。

    5．2编码数据格式

                 5．2．1 h264支持4：2：0的连续或隔行视频编码解码。

            5．2．2 h264的编码格式

    制定h264的主要目标有两个：

    （1）得到高的视频压缩比

    （2）具有良好的网络亲和性，即可适应于各种传输网络。

    为此，h264的功能分为两层，视频编码层（VCL）和网络提取层（NAL）

    VCL数据即被压缩编码后的视频数据序列。在VCL数据要封装到NAL单元中之后，才可以用来传输或存储。NAL单元格式如下图：

    Nal头

    Rbsp

    Nal头

    Rbsp

    Nal头

    Rbsp

                 5．2．3         h264码流结构

    查看(15) 评论(0)

  • H.264解码器中参考图像的管理(转自 李世平)

    2008-7-28

    【写在前面】
    由于H.264采用了多参考帧预测技术，所以其参考图象的管理比较复杂。GO50只是说明了怎么用，没有讲明为什么这么用，大家看过之后往往会有很多疑惑。本文比较细致的讲解了参考图象管理的问题，旨在进一步揭开其朦胧的面纱：）
    NOTE：为了便于从宏观角度讲解参考图象的管理，本文没有考虑B帧和场模式。
    PS：在H.264中，编解码器要维护参考图像列表的同步，所以在编码器和解码器中参考图像的管理是基本一致。在看此篇之前，大家可以先看看我以前写的《JM85中的多参考帧问题》: http://blog.csdn.net/sunshine1314/archive/2004/11/08/172498.aspx
     
    【outline】
    一、相关变量含义
    二、解码流程（突出参考图像管理部分）
    三、参考图像的标记
    四、参考图像的初始化
    五、参考图像的重排序
     
    一、相关变量含义
    DPB(Decoded Picture Buffer): 保存所有的重建图像，
    ListX[i]: 参考帧列表，其包含的参考帧指向dpb中的重建图像，而且是经过排序的。ListX[0]是前向参考帧列表，P、B帧都会用到；ListX[1]是后向参考帧列表，只有B帧都会用到，
    MaxFrameNum： 1 << (active_sps->log2_max_frame_num_minus4 + 4);
    frame_num：表示参考帧的序号（指的是解码顺序）。具体见图1的例子。
    图1 frame_num取值示例
    note:
    B帧不作参考时，我们可以忽略B帧，然后I/P帧按排列顺序是依次递增得。
    B帧作参考时，frame_num就完全等同与编解码得顺序。
    PicNum: 短期参考图像的序号，其计算过程如下：
    //note: frame_num为当前图象的序号
    if(listX[i]->frame_num > frame_num)
    {
           FrameNumWrap=listX[i]->frame_num - frame_num;
    }
    else
           FrameNumWrap=listX[i]->frame_num;
     
    listX[i]->PicNum=FrameNumWrap;
    LongTermPicNum: 长期参考图象的序号，外部指定。
     
    二、解码流程（突出参考图像管理部分）
    图2 解码流程
    参考图像列表初始化：将DBP中符合要求的重建图像放到listX[0]，并进行排序。
    参考图像列表重排序：根据当前slice码流中的句法元素，对listX[0]进行重排序。
    参考图像的标记：对DBP中的重建图像进行标记，可标记为：不作参考，短期参考，或长期参考。
     
    二、参考图像的标记
    note: 之所以先讲参考图像的标记，是为了和实际解码的过程相一致，因为第1帧I帧是不需要用到参考帧的，只会保存参考帧。
    如果当前图像不作参考，则跳过该环节。
    1、保存重建图像到DPB
    如果当前图像是IDR帧，则根据读入的语法元素，指明是否清空DPB，另外，还确定将IDR帧作为长期参考还是短期参考。
    非IDR帧情况，当前帧作为短期参考插入DPB。
     
    2、参考图像标记
    参考图像标记有两种方法，自动滑窗法和自定义标记法，由相应的句法元素确定采用何种方法。
    自动滑窗法：即FIFO的方法，当DPB已满时，将DPB中PicNum最小的短期参考图像（即最早的参考图像）移出DPB。
    自定义标记法(adaptive_ref_pic_marking_mode)：在句法元素中指定将某一参考图像设置为何种类型的参考图像或移出。其命令如下表：
    表1 自定义参考图象标记命令
    命令
    标记操作
    0
    结束标记操作
    1
    将一个短期参考标记为非参考（即移出）
    2
    将一个长期参考标记为非参考（即移出）
    3
    将一个短期参考标记为长期参考
    4
    指定长期参考图像的最大数目
    5
    清空DBP，并禁用长期参考
    6
    将当前图像存为长期参考
     
    三、参考图像的初始化
    1、将DBP中符合要求的重建图像放到listX[0]
     
    2、排序
    listX[0]中，先放短期参考，再放长期参考，
    短期参考按PicNum降序排列，
    长期参考按LongTermPicNum升序排列。
    具体见表2的示例：
    表2 参考图象初始化排序实例
    四、参考图像的重排序
    为什么要重排序：节省码流，当一个序号(ref_idx)比较大的参考图象被用到的比例很大，这个时候将该参考图象的序号调小可以降低码率。这个过程即重排序。
     
    参考图象重排序的大致过程如下：
    对listX[0]中的参考图象进行遍历，每遍历到一个参考图象，读入句法元素reordering_of_pic_nums_idc，更新其参考图象序号。
     
    reordering_of_pic_nums_idc具体命令如下：
    0/1：指定短期参考图象序号，分别用加偏移量和减偏移量的方法
    2：指定长期参考图象序号
    3：结束重排序。
     
    参考图象重排序实例：
     
     

    查看(22) 评论(0)

  • H.264名词

    2008-7-28

    A

    ABT: 自适应块变换

    ABR: Average BitsRate - 平均码率

    AC: 交流

    ASO: Arbitrary Slice Order - 任意的片次序

    B

    Bottom POC: 底场序列号

    C

    CABAC: Context-based Adaptive Binary Arithmetic Coding - 基于上下文自适应二进制算术熵编码

    CAVLC: Context Adaptive Variable Length Coding - 基于上下文自适应可变长编码

    CBP: Coded Block Pattern - 编码模式

    CBR: Constant Bit Rate - 恒定比特速率

    CPB: Coded Picture Buffer - 编码图像缓存区

    D

    DCT: Discrete Cosine Transform - 离散余弦变换

    dec : 参考帧

    DC : 直流

    DPB: Decoded Picture Buffer - 解码图像缓存区

    E

    EBSP：扩展字节序列载荷

    EC: Error Concealment - 误码掩盖

    enc: 编码帧

    EOB: 块结束符

    F

    FME: 快速运动估计

    FMO: Flexible Macroblock Order - 灵活宏块次序

    G

    GOP: 图像组(相邻I帧之间的帧数)

    H

    HDTV: High Definition Television - 高清晰电视

    I

    IDCT: 反离散余弦变化

    IDR: Instantaneous Decoding Refresh - 即时解码刷新

    J

    K

    KAYAK: 隔行扫描序列

    L

    LSB: Least Significant Bit - 低有效位

    M

    MAD: Mean Average Differences - 平均残差绝对值

    MB: MacroBlock - 宏块                            

    MBAFF: Macroblock-Adaptive Frame-Field Coding - 宏块自适应帧场编码           MC : 运动补偿      

    ME: 运动估计

    MSB: Most Significant Bit - 高有效位

    MSE: Mean Square - 均方误差

    MVD: 预测矢量与当前矢量的差异 

    MVP: 预测矢量

    N

    NAL: Network Abstract Layer - 网络提取层

    NALU: Network Abstract Layer Unit - NAL单元

    NC: Number Current - 当前块值

    O

    P

    POC: Picture Order Count - 图像序列号

    POC Lsb: POC低有效位

    POC Msb : POC高有效位

    PPS: 图像参数集

    PSNR: Peak Signal to Noise Ratio - 峰值信噪比

    Q

    QP: Quantization Parameter - 量化参数

    QStep: 量化步长

    R

    RBSP: Raw Byte Sequence Payload - 原始字节序列负荷

    RC: Rate Control - 码率控制

    RD: 速率失真

    RDO : 率失真优化

    RDOPT: Rate Distortion Optimization Technology - 率失真优化技术

    S

    SAD: Sum of Absolute Difference - 绝对误差和

    SAE: Sum of Absolute Error - 绝对误差和

    SATD: 变换绝对差值总量

    SCP: Start_Code_Prefix_one_3bytes 起始码前缀 0x000001

    SEI: Supplemental Enhancement Information - 补充的增强信息

    SH: Slice Header - 片头

    SODB: String Of Data Bits - 数据比特串

    SPS: 序列参数集

    SSD: Sum of the Squared Differences - 误差平方和

    T 

    TC : 变换系数

    Top POC : 顶场序列号

    U

    UVLC: 统一可变长编码

    V

    VBR: Variable Bit Rate - 可变比特速率

    VBV: Video Buffer Verify(or Verifier) 视频缓冲验证(或验证器)

    VCL: Video Coding Layer - 视频编码层

    VLC: Variable Length Code - 变长编码                     

    VQ: Video Quality - 矢量量化

    W

    X

    Y

    Z                                                                          

    Zig-Zag: 之字变换扫描

     

    ABT帧间编码: 把变换编码预测误差的块尺寸与运动补偿的块尺寸相关联。ABT限制其最大可用的块尺寸为8x8。(帧间编码)

     

    I帧和IDR帧的区别？

    IDR帧的作用是立刻刷新, 使错误不致传播, 从IDR帧开始, 重新算一个新的序列开始编码。IDR会导致DPB清空，而 I 不会

     

    RD: RD标准主要衡量变换系数和相应预测模块相对于预测误差的效率。(帧间编码)

     

    SATD : SATD体现了变换中存在的预测误差。计算了预测误差的总量和变换的花费(花费视为对编码效率的估计)。(帧间编码)

     

    T1 : 拖尾系数，数目范围是0~3，如果正负1的个数大于3个，只有最后3个被视为拖尾系数，其余的被视为普通的非零系数。(CAVLC)   毕书P119

     

     

    备注：协议里的名词

    ASO                 任意条带顺序，条带编码可以不是光栅扫描顺序

    BAB                 二值Alpha块，用于标示区域的边界

    BAP                 身体动画参数

    块                  做变换的宏块区域 8x8 4x4

    块匹配              矩形图象区域上的运动估计

    块效应              图象的方块或矩形失真区域

    B帧                 双向运动补偿预测的编码图像(条带)

    CABAC               基于上下文的自适应二值算数编码

    CAE                 基于上下文的算数编码

    CAVLC               基于上下文的自适应变长编码

    色度                色彩差异分量

    CIF                 通用中间格式,一种彩色图像格式 352 x 288

    色彩空间            表示彩色图像的方法

    DCT                 离散余弦变换

    直接预测            一种编码模式,此模式中不传输运动适量

    DPCM                差分脉冲编码调制

    DSCQS               双激励连续质量等级，主管质量衡量的等级和方法

    DWT                 离散小波变换

    熵编码              降低冗余的编码方法

    错误隐藏            编码图像的后处理，以消除或减小可见的错误效应

    Exp-Colomb          指数哥伦布变长编码

    FAP                 脸部动画参数

    FBA                 脸部和身体动画

    FGS                 精细颗粒分级

    场                  隔行视频序列的偶数行或奇数行

    流程图              变换算法的图示表示

    FMO                 灵活的宏块顺序,宏块的编码顺序可以不是光栅扫描顺序

    完全搜索            一种运动估计算法

    GMC                 全局运动补偿，用于整个编码对象

    GOP                 图像组,编码视频图像的集合

    哈夫曼编码          降低冗余的编码方法

    HVS                 人体视觉系统，用来官场和解释视频图像的系统

    混合                以涌动补偿和变换为特征的编解码器

    IEC                 国际电工委员会,一个标准体；

    帧间编码            使用时间预测和补偿的视频帧编码

    隔行扫描            表示为一系列场的视频数据

    帧内编码            不使用时间预测的视频帧编码

    ISO                 国际标准化组织

    ITU                 国际�