falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
22319 Commits
32 Branches
1.0GB
Tree: ddb901b74d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ddb901b74d'
${ noResults }
FFmpeg/libavcodec/h264_cabac.c

1788 lines
73KB
Raw Blame History 

  1. /*

  2.  * H.26L/H.264/AVC/JVT/14496-10/... cabac decoding

  3.  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>

  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 libavcodec/h264_cabac.c

  24.  * H.264 / AVC / MPEG4 part10 cabac decoding.

  25.  * @author Michael Niedermayer <michaelni@gmx.at>

  26.  */

  27. 

  28. #define CABAC 1

  29. 

  30. #include "internal.h"

  31. #include "dsputil.h"

  32. #include "avcodec.h"

  33. #include "h264.h"

  34. #include "h264data.h"

  35. #include "h264_mvpred.h"

  36. #include "golomb.h"

  37. 

  38. #include "cabac.h"

  39. #if ARCH_X86

  40. #include "x86/h264_i386.h"

  41. #endif

  42. 

  43. //#undef NDEBUG

  44. #include <assert.h>

  45. 

  46. /* Cabac pre state table */

  47. 

  48. static const int8_t cabac_context_init_I[460][2] =

  49. {

  50.     /* 0 - 10 */

  51.     { 20, -15 }, {  2, 54 },  {  3,  74 }, { 20, -15 },

  52.     {  2,  54 }, {  3, 74 },  { -28,127 }, { -23, 104 },

  53.     { -6,  53 }, { -1, 54 },  {  7,  51 },

  54. 

  55.     /* 11 - 23 unsused for I */

  56.     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },

  57.     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },

  58.     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },

  59.     { 0, 0 },

  60. 

  61.     /* 24- 39 */

  62.     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },

  63.     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },

  64.     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },

  65.     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },

  66. 

  67.     /* 40 - 53 */

  68.     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },

  69.     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },

  70.     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },

  71.     { 0, 0 },    { 0, 0 },

  72. 

  73.     /* 54 - 59 */

  74.     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },

  75.     { 0, 0 },    { 0, 0 },

  76. 

  77.     /* 60 - 69 */

  78.     { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },

  79.     { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },

  80.     { 13, 41 },  { 3, 62 },

  81. 

  82.     /* 70 -> 87 */

  83.     { 0, 11 },   { 1, 55 },   { 0, 69 },     { -17, 127 },

  84.     { -13, 102 },{ 0, 82 },   { -7, 74 },    { -21, 107 },

  85.     { -27, 127 },{ -31, 127 },{ -24, 127 },  { -18, 95 },

  86.     { -27, 127 },{ -21, 114 },{ -30, 127 },  { -17, 123 },

  87.     { -12, 115 },{ -16, 122 },

  88. 

  89.     /* 88 -> 104 */

  90.     { -11, 115 },{ -12, 63 }, { -2, 68 },    { -15, 84 },

  91.     { -13, 104 },{ -3, 70 },  { -8, 93 },    { -10, 90 },

  92.     { -30, 127 },{ -1, 74 },  { -6, 97 },    { -7, 91 },

  93.     { -20, 127 },{ -4, 56 },  { -5, 82 },    { -7, 76 },

  94.     { -22, 125 },

  95. 

  96.     /* 105 -> 135 */

  97.     { -7, 93 },  { -11, 87 }, { -3, 77 },    { -5, 71 },

  98.     { -4, 63 },  { -4, 68 },  { -12, 84 },   { -7, 62 },

  99.     { -7, 65 },  { 8, 61 },   { 5, 56 },     { -2, 66 },

  100.     { 1, 64 },   { 0, 61 },   { -2, 78 },    { 1, 50 },

  101.     { 7, 52 },   { 10, 35 },  { 0, 44 },     { 11, 38 },

  102.     { 1, 45 },   { 0, 46 },   { 5, 44 },     { 31, 17 },

  103.     { 1, 51 },   { 7, 50 },   { 28, 19 },    { 16, 33 },

  104.     { 14, 62 },  { -13, 108 },{ -15, 100 },

  105. 

  106.     /* 136 -> 165 */

  107.     { -13, 101 },{ -13, 91 }, { -12, 94 },   { -10, 88 },

  108.     { -16, 84 }, { -10, 86 }, { -7, 83 },    { -13, 87 },

  109.     { -19, 94 }, { 1, 70 },   { 0, 72 },     { -5, 74 },

  110.     { 18, 59 },  { -8, 102 }, { -15, 100 },  { 0, 95 },

  111.     { -4, 75 },  { 2, 72 },   { -11, 75 },   { -3, 71 },

  112.     { 15, 46 },  { -13, 69 }, { 0, 62 },     { 0, 65 },

  113.     { 21, 37 },  { -15, 72 }, { 9, 57 },     { 16, 54 },

  114.     { 0, 62 },   { 12, 72 },

  115. 

  116.     /* 166 -> 196 */

  117.     { 24, 0 },   { 15, 9 },   { 8, 25 },     { 13, 18 },

  118.     { 15, 9 },   { 13, 19 },  { 10, 37 },    { 12, 18 },

  119.     { 6, 29 },   { 20, 33 },  { 15, 30 },    { 4, 45 },

  120.     { 1, 58 },   { 0, 62 },   { 7, 61 },     { 12, 38 },

  121.     { 11, 45 },  { 15, 39 },  { 11, 42 },    { 13, 44 },

  122.     { 16, 45 },  { 12, 41 },  { 10, 49 },    { 30, 34 },

  123.     { 18, 42 },  { 10, 55 },  { 17, 51 },    { 17, 46 },

  124.     { 0, 89 },   { 26, -19 }, { 22, -17 },

  125. 

  126.     /* 197 -> 226 */

  127.     { 26, -17 }, { 30, -25 }, { 28, -20 },   { 33, -23 },

  128.     { 37, -27 }, { 33, -23 }, { 40, -28 },   { 38, -17 },

  129.     { 33, -11 }, { 40, -15 }, { 41, -6 },    { 38, 1 },

  130.     { 41, 17 },  { 30, -6 },  { 27, 3 },     { 26, 22 },

  131.     { 37, -16 }, { 35, -4 },  { 38, -8 },    { 38, -3 },

  132.     { 37, 3 },   { 38, 5 },   { 42, 0 },     { 35, 16 },

  133.     { 39, 22 },  { 14, 48 },  { 27, 37 },    { 21, 60 },

  134.     { 12, 68 },  { 2, 97 },

  135. 

  136.     /* 227 -> 251 */

  137.     { -3, 71 },  { -6, 42 },  { -5, 50 },    { -3, 54 },

  138.     { -2, 62 },  { 0, 58 },   { 1, 63 },     { -2, 72 },

  139.     { -1, 74 },  { -9, 91 },  { -5, 67 },    { -5, 27 },

  140.     { -3, 39 },  { -2, 44 },  { 0, 46 },     { -16, 64 },

  141.     { -8, 68 },  { -10, 78 }, { -6, 77 },    { -10, 86 },

  142.     { -12, 92 }, { -15, 55 }, { -10, 60 },   { -6, 62 },

  143.     { -4, 65 },

  144. 

  145.     /* 252 -> 275 */

  146.     { -12, 73 }, { -8, 76 },  { -7, 80 },    { -9, 88 },

  147.     { -17, 110 },{ -11, 97 }, { -20, 84 },   { -11, 79 },

  148.     { -6, 73 },  { -4, 74 },  { -13, 86 },   { -13, 96 },

  149.     { -11, 97 }, { -19, 117 },{ -8, 78 },    { -5, 33 },

  150.     { -4, 48 },  { -2, 53 },  { -3, 62 },    { -13, 71 },

  151.     { -10, 79 }, { -12, 86 }, { -13, 90 },   { -14, 97 },

  152. 

  153.     /* 276 a bit special (not used, bypass is used instead) */

  154.     { 0, 0 },

  155. 

  156.     /* 277 -> 307 */

  157.     { -6, 93 },  { -6, 84 },  { -8, 79 },    { 0, 66 },

  158.     { -1, 71 },  { 0, 62 },   { -2, 60 },    { -2, 59 },

  159.     { -5, 75 },  { -3, 62 },  { -4, 58 },    { -9, 66 },

  160.     { -1, 79 },  { 0, 71 },   { 3, 68 },     { 10, 44 },

  161.     { -7, 62 },  { 15, 36 },  { 14, 40 },    { 16, 27 },

  162.     { 12, 29 },  { 1, 44 },   { 20, 36 },    { 18, 32 },

  163.     { 5, 42 },   { 1, 48 },   { 10, 62 },    { 17, 46 },

  164.     { 9, 64 },   { -12, 104 },{ -11, 97 },

  165. 

  166.     /* 308 -> 337 */

  167.     { -16, 96 }, { -7, 88 },  { -8, 85 },    { -7, 85 },

  168.     { -9, 85 },  { -13, 88 }, { 4, 66 },     { -3, 77 },

  169.     { -3, 76 },  { -6, 76 },  { 10, 58 },    { -1, 76 },

  170.     { -1, 83 },  { -7, 99 },  { -14, 95 },   { 2, 95 },

  171.     { 0, 76 },   { -5, 74 },  { 0, 70 },     { -11, 75 },

  172.     { 1, 68 },   { 0, 65 },   { -14, 73 },   { 3, 62 },

  173.     { 4, 62 },   { -1, 68 },  { -13, 75 },   { 11, 55 },

  174.     { 5, 64 },   { 12, 70 },

  175. 

  176.     /* 338 -> 368 */

  177.     { 15, 6 },   { 6, 19 },   { 7, 16 },     { 12, 14 },

  178.     { 18, 13 },  { 13, 11 },  { 13, 15 },    { 15, 16 },

  179.     { 12, 23 },  { 13, 23 },  { 15, 20 },    { 14, 26 },

  180.     { 14, 44 },  { 17, 40 },  { 17, 47 },    { 24, 17 },

  181.     { 21, 21 },  { 25, 22 },  { 31, 27 },    { 22, 29 },

  182.     { 19, 35 },  { 14, 50 },  { 10, 57 },    { 7, 63 },

  183.     { -2, 77 },  { -4, 82 },  { -3, 94 },    { 9, 69 },

  184.     { -12, 109 },{ 36, -35 }, { 36, -34 },

  185. 

  186.     /* 369 -> 398 */

  187.     { 32, -26 }, { 37, -30 }, { 44, -32 },   { 34, -18 },

  188.     { 34, -15 }, { 40, -15 }, { 33, -7 },    { 35, -5 },

  189.     { 33, 0 },   { 38, 2 },   { 33, 13 },    { 23, 35 },

  190.     { 13, 58 },  { 29, -3 },  { 26, 0 },     { 22, 30 },

  191.     { 31, -7 },  { 35, -15 }, { 34, -3 },    { 34, 3 },

  192.     { 36, -1 },  { 34, 5 },   { 32, 11 },    { 35, 5 },

  193.     { 34, 12 },  { 39, 11 },  { 30, 29 },    { 34, 26 },

  194.     { 29, 39 },  { 19, 66 },

  195. 

  196.     /* 399 -> 435 */

  197.     {  31,  21 }, {  31,  31 }, {  25,  50 },

  198.     { -17, 120 }, { -20, 112 }, { -18, 114 }, { -11,  85 },

  199.     { -15,  92 }, { -14,  89 }, { -26,  71 }, { -15,  81 },

  200.     { -14,  80 }, {   0,  68 }, { -14,  70 }, { -24,  56 },

  201.     { -23,  68 }, { -24,  50 }, { -11,  74 }, {  23, -13 },

  202.     {  26, -13 }, {  40, -15 }, {  49, -14 }, {  44,   3 },

  203.     {  45,   6 }, {  44,  34 }, {  33,  54 }, {  19,  82 },

  204.     {  -3,  75 }, {  -1,  23 }, {   1,  34 }, {   1,  43 },

  205.     {   0,  54 }, {  -2,  55 }, {   0,  61 }, {   1,  64 },

  206.     {   0,  68 }, {  -9,  92 },

  207. 

  208.     /* 436 -> 459 */

  209.     { -14, 106 }, { -13,  97 }, { -15,  90 }, { -12,  90 },

  210.     { -18,  88 }, { -10,  73 }, {  -9,  79 }, { -14,  86 },

  211.     { -10,  73 }, { -10,  70 }, { -10,  69 }, {  -5,  66 },

  212.     {  -9,  64 }, {  -5,  58 }, {   2,  59 }, {  21, -10 },

  213.     {  24, -11 }, {  28,  -8 }, {  28,  -1 }, {  29,   3 },

  214.     {  29,   9 }, {  35,  20 }, {  29,  36 }, {  14,  67 }

  215. };

  216. 

  217. static const int8_t cabac_context_init_PB[3][460][2] =

  218. {

  219.     /* i_cabac_init_idc == 0 */

  220.     {

  221.         /* 0 - 10 */

  222.         {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },

  223.         {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },

  224.         {  -6,  53 }, {  -1,  54 }, {   7,  51 },

  225. 

  226.         /* 11 - 23 */

  227.         {  23,  33 }, {  23,   2 }, {  21,   0 }, {   1,   9 },

  228.         {   0,  49 }, { -37, 118 }, {   5,  57 }, { -13,  78 },

  229.         { -11,  65 }, {   1,  62 }, {  12,  49 }, {  -4,  73 },

  230.         {  17,  50 },

  231. 

  232.         /* 24 - 39 */

  233.         {  18,  64 }, {   9,  43 }, {  29,   0 }, {  26,  67 },

  234.         {  16,  90 }, {   9, 104 }, { -46, 127 }, { -20, 104 },

  235.         {   1,  67 }, { -13,  78 }, { -11,  65 }, {   1,  62 },

  236.         {  -6,  86 }, { -17,  95 }, {  -6,  61 }, {   9,  45 },

  237. 

  238.         /* 40 - 53 */

  239.         {  -3,  69 }, {  -6,  81 }, { -11,  96 }, {   6,  55 },

  240.         {   7,  67 }, {  -5,  86 }, {   2,  88 }, {   0,  58 },

  241.         {  -3,  76 }, { -10,  94 }, {   5,  54 }, {   4,  69 },

  242.         {  -3,  81 }, {   0,  88 },

  243. 

  244.         /* 54 - 59 */

  245.         {  -7,  67 }, {  -5,  74 }, {  -4,  74 }, {  -5,  80 },

  246.         {  -7,  72 }, {   1,  58 },

  247. 

  248.         /* 60 - 69 */

  249.         {   0,  41 }, {   0,  63 }, {   0,  63 }, { 0, 63 },

  250.         {  -9,  83 }, {   4,  86 }, {   0,  97 }, { -7, 72 },

  251.         {  13,  41 }, {   3,  62 },

  252. 

  253.         /* 70 - 87 */

  254.         {   0,  45 }, {  -4,  78 }, {  -3,  96 }, { -27,  126 },

  255.         { -28,  98 }, { -25, 101 }, { -23,  67 }, { -28,  82 },

  256.         { -20,  94 }, { -16,  83 }, { -22, 110 }, { -21,  91 },

  257.         { -18, 102 }, { -13,  93 }, { -29, 127 }, {  -7,  92 },

  258.         {  -5,  89 }, {  -7,  96 }, { -13, 108 }, {  -3,  46 },

  259.         {  -1,  65 }, {  -1,  57 }, {  -9,  93 }, {  -3,  74 },

  260.         {  -9,  92 }, {  -8,  87 }, { -23, 126 }, {   5,  54 },

  261.         {   6,  60 }, {   6,  59 }, {   6,  69 }, {  -1,  48 },

  262.         {   0,  68 }, {  -4,  69 }, {  -8,  88 },

  263. 

  264.         /* 105 -> 165 */

  265.         {  -2,  85 }, {  -6,  78 }, {  -1,  75 }, {  -7,  77 },

  266.         {   2,  54 }, {   5,  50 }, {  -3,  68 }, {   1,  50 },

  267.         {   6,  42 }, {  -4,  81 }, {   1,  63 }, {  -4,  70 },

  268.         {   0,  67 }, {   2,  57 }, {  -2,  76 }, {  11,  35 },

  269.         {   4,  64 }, {   1,  61 }, {  11,  35 }, {  18,  25 },

  270.         {  12,  24 }, {  13,  29 }, {  13,  36 }, { -10,  93 },

  271.         {  -7,  73 }, {  -2,  73 }, {  13,  46 }, {   9,  49 },

  272.         {  -7, 100 }, {   9,  53 }, {   2,  53 }, {   5,  53 },

  273.         {  -2,  61 }, {   0,  56 }, {   0,  56 }, { -13,  63 },

  274.         {  -5,  60 }, {  -1,  62 }, {   4,  57 }, {  -6,  69 },

  275.         {   4,  57 }, {  14,  39 }, {   4,  51 }, {  13,  68 },

  276.         {   3,  64 }, {   1,  61 }, {   9,  63 }, {   7,  50 },

  277.         {  16,  39 }, {   5,  44 }, {   4,  52 }, {  11,  48 },

  278.         {  -5,  60 }, {  -1,  59 }, {   0,  59 }, {  22,  33 },

  279.         {   5,  44 }, {  14,  43 }, {  -1,  78 }, {   0,  60 },

  280.         {   9,  69 },

  281. 

  282.         /* 166 - 226 */

  283.         {  11,  28 }, {   2,  40 }, {   3,  44 }, {   0,  49 },

  284.         {   0,  46 }, {   2,  44 }, {   2,  51 }, {   0,  47 },

  285.         {   4,  39 }, {   2,  62 }, {   6,  46 }, {   0,  54 },

  286.         {   3,  54 }, {   2,  58 }, {   4,  63 }, {   6,  51 },

  287.         {   6,  57 }, {   7,  53 }, {   6,  52 }, {   6,  55 },

  288.         {  11,  45 }, {  14,  36 }, {   8,  53 }, {  -1,  82 },

  289.         {   7,  55 }, {  -3,  78 }, {  15,  46 }, {  22,  31 },

  290.         {  -1,  84 }, {  25,   7 }, {  30,  -7 }, {  28,   3 },

  291.         {  28,   4 }, {  32,   0 }, {  34,  -1 }, {  30,   6 },

  292.         {  30,   6 }, {  32,   9 }, {  31,  19 }, {  26,  27 },

  293.         {  26,  30 }, {  37,  20 }, {  28,  34 }, {  17,  70 },

  294.         {   1,  67 }, {   5,  59 }, {   9,  67 }, {  16,  30 },

  295.         {  18,  32 }, {  18,  35 }, {  22,  29 }, {  24,  31 },

  296.         {  23,  38 }, {  18,  43 }, {  20,  41 }, {  11,  63 },

  297.         {   9,  59 }, {   9,  64 }, {  -1,  94 }, {  -2,  89 },

  298.         {  -9, 108 },

  299. 

  300.         /* 227 - 275 */

  301.         {  -6,  76 }, {  -2,  44 }, {   0,  45 }, {   0,  52 },

  302.         {  -3,  64 }, {  -2,  59 }, {  -4,  70 }, {  -4,  75 },

  303.         {  -8,  82 }, { -17, 102 }, {  -9,  77 }, {   3,  24 },

  304.         {   0,  42 }, {   0,  48 }, {   0,  55 }, {  -6,  59 },

  305.         {  -7,  71 }, { -12,  83 }, { -11,  87 }, { -30, 119 },

  306.         {   1,  58 }, {  -3,  29 }, {  -1,  36 }, {   1,  38 },

  307.         {   2,  43 }, {  -6,  55 }, {   0,  58 }, {   0,  64 },

  308.         {  -3,  74 }, { -10,  90 }, {   0,  70 }, {  -4,  29 },

  309.         {   5,  31 }, {   7,  42 }, {   1,  59 }, {  -2,  58 },

  310.         {  -3,  72 }, {  -3,  81 }, { -11,  97 }, {   0,  58 },

  311.         {   8,   5 }, {  10,  14 }, {  14,  18 }, {  13,  27 },

  312.         {   2,  40 }, {   0,  58 }, {  -3,  70 }, {  -6,  79 },

  313.         {  -8,  85 },

  314. 

  315.         /* 276 a bit special (not used, bypass is used instead) */

  316.         { 0, 0 },

  317. 

  318.         /* 277 - 337 */

  319.         { -13, 106 }, { -16, 106 }, { -10,  87 }, { -21, 114 },

  320.         { -18, 110 }, { -14,  98 }, { -22, 110 }, { -21, 106 },

  321.         { -18, 103 }, { -21, 107 }, { -23, 108 }, { -26, 112 },

  322.         { -10,  96 }, { -12,  95 }, {  -5,  91 }, {  -9,  93 },

  323.         { -22,  94 }, {  -5,  86 }, {   9,  67 }, {  -4,  80 },

  324.         { -10,  85 }, {  -1,  70 }, {   7,  60 }, {   9,  58 },

  325.         {   5,  61 }, {  12,  50 }, {  15,  50 }, {  18,  49 },

  326.         {  17,  54 }, {  10,  41 }, {   7,  46 }, {  -1,  51 },

  327.         {   7,  49 }, {   8,  52 }, {   9,  41 }, {   6,  47 },

  328.         {   2,  55 }, {  13,  41 }, {  10,  44 }, {   6,  50 },

  329.         {   5,  53 }, {  13,  49 }, {   4,  63 }, {   6,  64 },

  330.         {  -2,  69 }, {  -2,  59 }, {   6,  70 }, {  10,  44 },

  331.         {   9,  31 }, {  12,  43 }, {   3,  53 }, {  14,  34 },

  332.         {  10,  38 }, {  -3,  52 }, {  13,  40 }, {  17,  32 },

  333.         {   7,  44 }, {   7,  38 }, {  13,  50 }, {  10,  57 },

  334.         {  26,  43 },

  335. 

  336.         /* 338 - 398 */

  337.         {  14,  11 }, {  11,  14 }, {   9,  11 }, {  18,  11 },

  338.         {  21,   9 }, {  23,  -2 }, {  32, -15 }, {  32, -15 },

  339.         {  34, -21 }, {  39, -23 }, {  42, -33 }, {  41, -31 },

  340.         {  46, -28 }, {  38, -12 }, {  21,  29 }, {  45, -24 },

  341.         {  53, -45 }, {  48, -26 }, {  65, -43 }, {  43, -19 },

  342.         {  39, -10 }, {  30,   9 }, {  18,  26 }, {  20,  27 },

  343.         {   0,  57 }, { -14,  82 }, {  -5,  75 }, { -19,  97 },

  344.         { -35, 125 }, {  27,   0 }, {  28,   0 }, {  31,  -4 },

  345.         {  27,   6 }, {  34,   8 }, {  30,  10 }, {  24,  22 },

  346.         {  33,  19 }, {  22,  32 }, {  26,  31 }, {  21,  41 },

  347.         {  26,  44 }, {  23,  47 }, {  16,  65 }, {  14,  71 },

  348.         {   8,  60 }, {   6,  63 }, {  17,  65 }, {  21,  24 },

  349.         {  23,  20 }, {  26,  23 }, {  27,  32 }, {  28,  23 },

  350.         {  28,  24 }, {  23,  40 }, {  24,  32 }, {  28,  29 },

  351.         {  23,  42 }, {  19,  57 }, {  22,  53 }, {  22,  61 },

  352.         {  11,  86 },

  353. 

  354.         /* 399 - 435 */

  355.         {  12,  40 }, {  11,  51 }, {  14,  59 },

  356.         {  -4,  79 }, {  -7,  71 }, {  -5,  69 }, {  -9,  70 },

  357.         {  -8,  66 }, { -10,  68 }, { -19,  73 }, { -12,  69 },

  358.         { -16,  70 }, { -15,  67 }, { -20,  62 }, { -19,  70 },

  359.         { -16,  66 }, { -22,  65 }, { -20,  63 }, {   9,  -2 },

  360.         {  26,  -9 }, {  33,  -9 }, {  39,  -7 }, {  41,  -2 },

  361.         {  45,   3 }, {  49,   9 }, {  45,  27 }, {  36,  59 },

  362.         {  -6,  66 }, {  -7,  35 }, {  -7,  42 }, {  -8,  45 },

  363.         {  -5,  48 }, { -12,  56 }, {  -6,  60 }, {  -5,  62 },

  364.         {  -8,  66 }, {  -8,  76 },

  365. 

  366.         /* 436 - 459 */

  367.         {  -5,  85 }, {  -6,  81 }, { -10,  77 }, {  -7,  81 },

  368.         { -17,  80 }, { -18,  73 }, {  -4,  74 }, { -10,  83 },

  369.         {  -9,  71 }, {  -9,  67 }, {  -1,  61 }, {  -8,  66 },

  370.         { -14,  66 }, {   0,  59 }, {   2,  59 }, {  21, -13 },

  371.         {  33, -14 }, {  39,  -7 }, {  46,  -2 }, {  51,   2 },

  372.         {  60,   6 }, {  61,  17 }, {  55,  34 }, {  42,  62 },

  373.     },

  374. 

  375.     /* i_cabac_init_idc == 1 */

  376.     {

  377.         /* 0 - 10 */

  378.         {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },

  379.         {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },

  380.         {  -6,  53 }, {  -1,  54 }, {   7,  51 },

  381. 

  382.         /* 11 - 23 */

  383.         {  22,  25 }, {  34,   0 }, {  16,   0 }, {  -2,   9 },

  384.         {   4,  41 }, { -29, 118 }, {   2,  65 }, {  -6,  71 },

  385.         { -13,  79 }, {   5,  52 }, {   9,  50 }, {  -3,  70 },

  386.         {  10,  54 },

  387. 

  388.         /* 24 - 39 */

  389.         {  26,  34 }, {  19,  22 }, {  40,   0 }, {  57,   2 },

  390.         {  41,  36 }, {  26,  69 }, { -45, 127 }, { -15, 101 },

  391.         {  -4,  76 }, {  -6,  71 }, { -13,  79 }, {   5,  52 },

  392.         {   6,  69 }, { -13,  90 }, {   0,  52 }, {   8,  43 },

  393. 

  394.         /* 40 - 53 */

  395.         {  -2,  69 },{  -5,  82 },{ -10,  96 },{   2,  59 },

  396.         {   2,  75 },{  -3,  87 },{  -3,  100 },{   1,  56 },

  397.         {  -3,  74 },{  -6,  85 },{   0,  59 },{  -3,  81 },

  398.         {  -7,  86 },{  -5,  95 },

  399. 

  400.         /* 54 - 59 */

  401.         {  -1,  66 },{  -1,  77 },{   1,  70 },{  -2,  86 },

  402.         {  -5,  72 },{   0,  61 },

  403. 

  404.         /* 60 - 69 */

  405.         { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },

  406.         { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },

  407.         { 13, 41 },  { 3, 62 },

  408. 

  409.         /* 70 - 104 */

  410.         {  13,  15 }, {   7,  51 }, {   2,  80 }, { -39, 127 },

  411.         { -18,  91 }, { -17,  96 }, { -26,  81 }, { -35,  98 },

  412.         { -24, 102 }, { -23,  97 }, { -27, 119 }, { -24,  99 },

  413.         { -21, 110 }, { -18, 102 }, { -36, 127 }, {   0,  80 },

  414.         {  -5,  89 }, {  -7,  94 }, {  -4,  92 }, {   0,  39 },

  415.         {   0,  65 }, { -15,  84 }, { -35, 127 }, {  -2,  73 },

  416.         { -12, 104 }, {  -9,  91 }, { -31, 127 }, {   3,  55 },

  417.         {   7,  56 }, {   7,  55 }, {   8,  61 }, {  -3,  53 },

  418.         {   0,  68 }, {  -7,  74 }, {  -9,  88 },

  419. 

  420.         /* 105 -> 165 */

  421.         { -13, 103 }, { -13,  91 }, {  -9,  89 }, { -14,  92 },

  422.         {  -8,  76 }, { -12,  87 }, { -23, 110 }, { -24, 105 },

  423.         { -10,  78 }, { -20, 112 }, { -17,  99 }, { -78, 127 },

  424.         { -70, 127 }, { -50, 127 }, { -46, 127 }, {  -4,  66 },

  425.         {  -5,  78 }, {  -4,  71 }, {  -8,  72 }, {   2,  59 },

  426.         {  -1,  55 }, {  -7,  70 }, {  -6,  75 }, {  -8,  89 },

  427.         { -34, 119 }, {  -3,  75 }, {  32,  20 }, {  30,  22 },

  428.         { -44, 127 }, {   0,  54 }, {  -5,  61 }, {   0,  58 },

  429.         {  -1,  60 }, {  -3,  61 }, {  -8,  67 }, { -25,  84 },

  430.         { -14,  74 }, {  -5,  65 }, {   5,  52 }, {   2,  57 },

  431.         {   0,  61 }, {  -9,  69 }, { -11,  70 }, {  18,  55 },

  432.         {  -4,  71 }, {   0,  58 }, {   7,  61 }, {   9,  41 },

  433.         {  18,  25 }, {   9,  32 }, {   5,  43 }, {   9,  47 },

  434.         {   0,  44 }, {   0,  51 }, {   2,  46 }, {  19,  38 },

  435.         {  -4,  66 }, {  15,  38 }, {  12,  42 }, {   9,  34 },

  436.         {   0,  89 },

  437. 

  438.         /* 166 - 226 */

  439.         {   4,  45 }, {  10,  28 }, {  10,  31 }, {  33, -11 },

  440.         {  52, -43 }, {  18,  15 }, {  28,   0 }, {  35, -22 },

  441.         {  38, -25 }, {  34,   0 }, {  39, -18 }, {  32, -12 },

  442.         { 102, -94 }, {   0,   0 }, {  56, -15 }, {  33,  -4 },

  443.         {  29,  10 }, {  37,  -5 }, {  51, -29 }, {  39,  -9 },

  444.         {  52, -34 }, {  69, -58 }, {  67, -63 }, {  44,  -5 },

  445.         {  32,   7 }, {  55, -29 }, {  32,   1 }, {   0,   0 },

  446.         {  27,  36 }, {  33, -25 }, {  34, -30 }, {  36, -28 },

  447.         {  38, -28 }, {  38, -27 }, {  34, -18 }, {  35, -16 },

  448.         {  34, -14 }, {  32,  -8 }, {  37,  -6 }, {  35,   0 },

  449.         {  30,  10 }, {  28,  18 }, {  26,  25 }, {  29,  41 },

  450.         {   0,  75 }, {   2,  72 }, {   8,  77 }, {  14,  35 },

  451.         {  18,  31 }, {  17,  35 }, {  21,  30 }, {  17,  45 },

  452.         {  20,  42 }, {  18,  45 }, {  27,  26 }, {  16,  54 },

  453.         {   7,  66 }, {  16,  56 }, {  11,  73 }, {  10,  67 },

  454.         { -10, 116 },

  455. 

  456.         /* 227 - 275 */

  457.         { -23, 112 }, { -15,  71 }, {  -7,  61 }, {   0,  53 },

  458.         {  -5,  66 }, { -11,  77 }, {  -9,  80 }, {  -9,  84 },

  459.         { -10,  87 }, { -34, 127 }, { -21, 101 }, {  -3,  39 },

  460.         {  -5,  53 }, {  -7,  61 }, { -11,  75 }, { -15,  77 },

  461.         { -17,  91 }, { -25, 107 }, { -25, 111 }, { -28, 122 },

  462.         { -11,  76 }, { -10,  44 }, { -10,  52 }, { -10,  57 },

  463.         {  -9,  58 }, { -16,  72 }, {  -7,  69 }, {  -4,  69 },

  464.         {  -5,  74 }, {  -9,  86 }, {   2,  66 }, {  -9,  34 },

  465.         {   1,  32 }, {  11,  31 }, {   5,  52 }, {  -2,  55 },

  466.         {  -2,  67 }, {   0,  73 }, {  -8,  89 }, {   3,  52 },

  467.         {   7,   4 }, {  10,   8 }, {  17,   8 }, {  16,  19 },

  468.         {   3,  37 }, {  -1,  61 }, {  -5,  73 }, {  -1,  70 },

  469.         {  -4,  78 },

  470. 

  471.         /* 276 a bit special (not used, bypass is used instead) */

  472.         { 0, 0 },

  473. 

  474.         /* 277 - 337 */

  475.         { -21, 126 }, { -23, 124 }, { -20, 110 }, { -26, 126 },

  476.         { -25, 124 }, { -17, 105 }, { -27, 121 }, { -27, 117 },

  477.         { -17, 102 }, { -26, 117 }, { -27, 116 }, { -33, 122 },

  478.         { -10,  95 }, { -14, 100 }, {  -8,  95 }, { -17, 111 },

  479.         { -28, 114 }, {  -6,  89 }, {  -2,  80 }, {  -4,  82 },

  480.         {  -9,  85 }, {  -8,  81 }, {  -1,  72 }, {   5,  64 },

  481.         {   1,  67 }, {   9,  56 }, {   0,  69 }, {   1,  69 },

  482.         {   7,  69 }, {  -7,  69 }, {  -6,  67 }, { -16,  77 },

  483.         {  -2,  64 }, {   2,  61 }, {  -6,  67 }, {  -3,  64 },

  484.         {   2,  57 }, {  -3,  65 }, {  -3,  66 }, {   0,  62 },

  485.         {   9,  51 }, {  -1,  66 }, {  -2,  71 }, {  -2,  75 },

  486.         {  -1,  70 }, {  -9,  72 }, {  14,  60 }, {  16,  37 },

  487.         {   0,  47 }, {  18,  35 }, {  11,  37 }, {  12,  41 },

  488.         {  10,  41 }, {   2,  48 }, {  12,  41 }, {  13,  41 },

  489.         {   0,  59 }, {   3,  50 }, {  19,  40 }, {   3,  66 },

  490.         {  18,  50 },

  491. 

  492.         /* 338 - 398 */

  493.         {  19,  -6 }, {  18,  -6 }, {  14,   0 }, {  26, -12 },

  494.         {  31, -16 }, {  33, -25 }, {  33, -22 }, {  37, -28 },

  495.         {  39, -30 }, {  42, -30 }, {  47, -42 }, {  45, -36 },

  496.         {  49, -34 }, {  41, -17 }, {  32,   9 }, {  69, -71 },

  497.         {  63, -63 }, {  66, -64 }, {  77, -74 }, {  54, -39 },

  498.         {  52, -35 }, {  41, -10 }, {  36,   0 }, {  40,  -1 },

  499.         {  30,  14 }, {  28,  26 }, {  23,  37 }, {  12,  55 },

  500.         {  11,  65 }, {  37, -33 }, {  39, -36 }, {  40, -37 },

  501.         {  38, -30 }, {  46, -33 }, {  42, -30 }, {  40, -24 },

  502.         {  49, -29 }, {  38, -12 }, {  40, -10 }, {  38,  -3 },

  503.         {  46,  -5 }, {  31,  20 }, {  29,  30 }, {  25,  44 },

  504.         {  12,  48 }, {  11,  49 }, {  26,  45 }, {  22,  22 },

  505.         {  23,  22 }, {  27,  21 }, {  33,  20 }, {  26,  28 },

  506.         {  30,  24 }, {  27,  34 }, {  18,  42 }, {  25,  39 },

  507.         {  18,  50 }, {  12,  70 }, {  21,  54 }, {  14,  71 },

  508.         {  11,  83 },

  509. 

  510.         /* 399 - 435 */

  511.         {  25,  32 }, {  21,  49 }, {  21,  54 },

  512.         {  -5,  85 }, {  -6,  81 }, { -10,  77 }, {  -7,  81 },

  513.         { -17,  80 }, { -18,  73 }, {  -4,  74 }, { -10,  83 },

  514.         {  -9,  71 }, {  -9,  67 }, {  -1,  61 }, {  -8,  66 },

  515.         { -14,  66 }, {   0,  59 }, {   2,  59 }, {  17, -10 },

  516.         {  32, -13 }, {  42,  -9 }, {  49,  -5 }, {  53,   0 },

  517.         {  64,   3 }, {  68,  10 }, {  66,  27 }, {  47,  57 },

  518.         {  -5,  71 }, {   0,  24 }, {  -1,  36 }, {  -2,  42 },

  519.         {  -2,  52 }, {  -9,  57 }, {  -6,  63 }, {  -4,  65 },

  520.         {  -4,  67 }, {  -7,  82 },

  521. 

  522.         /* 436 - 459 */

  523.         {  -3,  81 }, {  -3,  76 }, {  -7,  72 }, {  -6,  78 },

  524.         { -12,  72 }, { -14,  68 }, {  -3,  70 }, {  -6,  76 },

  525.         {  -5,  66 }, {  -5,  62 }, {   0,  57 }, {  -4,  61 },

  526.         {  -9,  60 }, {   1,  54 }, {   2,  58 }, {  17, -10 },

  527.         {  32, -13 }, {  42,  -9 }, {  49,  -5 }, {  53,   0 },

  528.         {  64,   3 }, {  68,  10 }, {  66,  27 }, {  47,  57 },

  529.     },

  530. 

  531.     /* i_cabac_init_idc == 2 */

  532.     {

  533.         /* 0 - 10 */

  534.         {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },

  535.         {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },

  536.         {  -6,  53 }, {  -1,  54 }, {   7,  51 },

  537. 

  538.         /* 11 - 23 */

  539.         {  29,  16 }, {  25,   0 }, {  14,   0 }, { -10,  51 },

  540.         {  -3,  62 }, { -27,  99 }, {  26,  16 }, {  -4,  85 },

  541.         { -24, 102 }, {   5,  57 }, {   6,  57 }, { -17,  73 },

  542.         {  14,  57 },

  543. 

  544.         /* 24 - 39 */

  545.         {  20,  40 }, {  20,  10 }, {  29,   0 }, {  54,   0 },

  546.         {  37,  42 }, {  12,  97 }, { -32, 127 }, { -22, 117 },

  547.         {  -2,  74 }, {  -4,  85 }, { -24, 102 }, {   5,  57 },

  548.         {  -6,  93 }, { -14,  88 }, {  -6,  44 }, {   4,  55 },

  549. 

  550.         /* 40 - 53 */

  551.         { -11,  89 },{ -15,  103 },{ -21,  116 },{  19,  57 },

  552.         {  20,  58 },{   4,  84 },{   6,  96 },{   1,  63 },

  553.         {  -5,  85 },{ -13,  106 },{   5,  63 },{   6,  75 },

  554.         {  -3,  90 },{  -1,  101 },

  555. 

  556.         /* 54 - 59 */

  557.         {   3,  55 },{  -4,  79 },{  -2,  75 },{ -12,  97 },

  558.         {  -7,  50 },{   1,  60 },

  559. 

  560.         /* 60 - 69 */

  561.         { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },

  562.         { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },

  563.         { 13, 41 },  { 3, 62 },

  564. 

  565.         /* 70 - 104 */

  566.         {   7,  34 }, {  -9,  88 }, { -20, 127 }, { -36, 127 },

  567.         { -17,  91 }, { -14,  95 }, { -25,  84 }, { -25,  86 },

  568.         { -12,  89 }, { -17,  91 }, { -31, 127 }, { -14,  76 },

  569.         { -18, 103 }, { -13,  90 }, { -37, 127 }, {  11,  80 },

  570.         {   5,  76 }, {   2,  84 }, {   5,  78 }, {  -6,  55 },

  571.         {   4,  61 }, { -14,  83 }, { -37, 127 }, {  -5,  79 },

  572.         { -11, 104 }, { -11,  91 }, { -30, 127 }, {   0,  65 },

  573.         {  -2,  79 }, {   0,  72 }, {  -4,  92 }, {  -6,  56 },

  574.         {   3,  68 }, {  -8,  71 }, { -13,  98 },

  575. 

  576.         /* 105 -> 165 */

  577.         {  -4,  86 }, { -12,  88 }, {  -5,  82 }, {  -3,  72 },

  578.         {  -4,  67 }, {  -8,  72 }, { -16,  89 }, {  -9,  69 },

  579.         {  -1,  59 }, {   5,  66 }, {   4,  57 }, {  -4,  71 },

  580.         {  -2,  71 }, {   2,  58 }, {  -1,  74 }, {  -4,  44 },

  581.         {  -1,  69 }, {   0,  62 }, {  -7,  51 }, {  -4,  47 },

  582.         {  -6,  42 }, {  -3,  41 }, {  -6,  53 }, {   8,  76 },

  583.         {  -9,  78 }, { -11,  83 }, {   9,  52 }, {   0,  67 },

  584.         {  -5,  90 }, {   1,  67 }, { -15,  72 }, {  -5,  75 },

  585.         {  -8,  80 }, { -21,  83 }, { -21,  64 }, { -13,  31 },

  586.         { -25,  64 }, { -29,  94 }, {   9,  75 }, {  17,  63 },

  587.         {  -8,  74 }, {  -5,  35 }, {  -2,  27 }, {  13,  91 },

  588.         {   3,  65 }, {  -7,  69 }, {   8,  77 }, { -10,  66 },

  589.         {   3,  62 }, {  -3,  68 }, { -20,  81 }, {   0,  30 },

  590.         {   1,   7 }, {  -3,  23 }, { -21,  74 }, {  16,  66 },

  591.         { -23, 124 }, {  17,  37 }, {  44, -18 }, {  50, -34 },

  592.         { -22, 127 },

  593. 

  594.         /* 166 - 226 */

  595.         {   4,  39 }, {   0,  42 }, {   7,  34 }, {  11,  29 },

  596.         {   8,  31 }, {   6,  37 }, {   7,  42 }, {   3,  40 },

  597.         {   8,  33 }, {  13,  43 }, {  13,  36 }, {   4,  47 },

  598.         {   3,  55 }, {   2,  58 }, {   6,  60 }, {   8,  44 },

  599.         {  11,  44 }, {  14,  42 }, {   7,  48 }, {   4,  56 },

  600.         {   4,  52 }, {  13,  37 }, {   9,  49 }, {  19,  58 },

  601.         {  10,  48 }, {  12,  45 }, {   0,  69 }, {  20,  33 },

  602.         {   8,  63 }, {  35, -18 }, {  33, -25 }, {  28,  -3 },

  603.         {  24,  10 }, {  27,   0 }, {  34, -14 }, {  52, -44 },

  604.         {  39, -24 }, {  19,  17 }, {  31,  25 }, {  36,  29 },

  605.         {  24,  33 }, {  34,  15 }, {  30,  20 }, {  22,  73 },

  606.         {  20,  34 }, {  19,  31 }, {  27,  44 }, {  19,  16 },

  607.         {  15,  36 }, {  15,  36 }, {  21,  28 }, {  25,  21 },

  608.         {  30,  20 }, {  31,  12 }, {  27,  16 }, {  24,  42 },

  609.         {   0,  93 }, {  14,  56 }, {  15,  57 }, {  26,  38 },

  610.         { -24, 127 },

  611. 

  612.         /* 227 - 275 */

  613.         { -24, 115 }, { -22,  82 }, {  -9,  62 }, {   0,  53 },

  614.         {   0,  59 }, { -14,  85 }, { -13,  89 }, { -13,  94 },

  615.         { -11,  92 }, { -29, 127 }, { -21, 100 }, { -14,  57 },

  616.         { -12,  67 }, { -11,  71 }, { -10,  77 }, { -21,  85 },

  617.         { -16,  88 }, { -23, 104 }, { -15,  98 }, { -37, 127 },

  618.         { -10,  82 }, {  -8,  48 }, {  -8,  61 }, {  -8,  66 },

  619.         {  -7,  70 }, { -14,  75 }, { -10,  79 }, {  -9,  83 },

  620.         { -12,  92 }, { -18, 108 }, {  -4,  79 }, { -22,  69 },

  621.         { -16,  75 }, {  -2,  58 }, {   1,  58 }, { -13,  78 },

  622.         {  -9,  83 }, {  -4,  81 }, { -13,  99 }, { -13,  81 },

  623.         {  -6,  38 }, { -13,  62 }, {  -6,  58 }, {  -2,  59 },

  624.         { -16,  73 }, { -10,  76 }, { -13,  86 }, {  -9,  83 },

  625.         { -10,  87 },

  626. 

  627.         /* 276 a bit special (not used, bypass is used instead) */

  628.         { 0, 0 },

  629. 

  630.         /* 277 - 337 */

  631.         { -22, 127 }, { -25, 127 }, { -25, 120 }, { -27, 127 },

  632.         { -19, 114 }, { -23, 117 }, { -25, 118 }, { -26, 117 },

  633.         { -24, 113 }, { -28, 118 }, { -31, 120 }, { -37, 124 },

  634.         { -10,  94 }, { -15, 102 }, { -10,  99 }, { -13, 106 },

  635.         { -50, 127 }, {  -5,  92 }, {  17,  57 }, {  -5,  86 },

  636.         { -13,  94 }, { -12,  91 }, {  -2,  77 }, {   0,  71 },

  637.         {  -1,  73 }, {   4,  64 }, {  -7,  81 }, {   5,  64 },

  638.         {  15,  57 }, {   1,  67 }, {   0,  68 }, { -10,  67 },

  639.         {   1,  68 }, {   0,  77 }, {   2,  64 }, {   0,  68 },

  640.         {  -5,  78 }, {   7,  55 }, {   5,  59 }, {   2,  65 },

  641.         {  14,  54 }, {  15,  44 }, {   5,  60 }, {   2,  70 },

  642.         {  -2,  76 }, { -18,  86 }, {  12,  70 }, {   5,  64 },

  643.         { -12,  70 }, {  11,  55 }, {   5,  56 }, {   0,  69 },

  644.         {   2,  65 }, {  -6,  74 }, {   5,  54 }, {   7,  54 },

  645.         {  -6,  76 }, { -11,  82 }, {  -2,  77 }, {  -2,  77 },

  646.         {  25,  42 },

  647. 

  648.         /* 338 - 398 */

  649.         {  17, -13 }, {  16,  -9 }, {  17, -12 }, {  27, -21 },

  650.         {  37, -30 }, {  41, -40 }, {  42, -41 }, {  48, -47 },

  651.         {  39, -32 }, {  46, -40 }, {  52, -51 }, {  46, -41 },

  652.         {  52, -39 }, {  43, -19 }, {  32,  11 }, {  61, -55 },

  653.         {  56, -46 }, {  62, -50 }, {  81, -67 }, {  45, -20 },

  654.         {  35,  -2 }, {  28,  15 }, {  34,   1 }, {  39,   1 },

  655.         {  30,  17 }, {  20,  38 }, {  18,  45 }, {  15,  54 },

  656.         {   0,  79 }, {  36, -16 }, {  37, -14 }, {  37, -17 },

  657.         {  32,   1 }, {  34,  15 }, {  29,  15 }, {  24,  25 },

  658.         {  34,  22 }, {  31,  16 }, {  35,  18 }, {  31,  28 },

  659.         {  33,  41 }, {  36,  28 }, {  27,  47 }, {  21,  62 },

  660.         {  18,  31 }, {  19,  26 }, {  36,  24 }, {  24,  23 },

  661.         {  27,  16 }, {  24,  30 }, {  31,  29 }, {  22,  41 },

  662.         {  22,  42 }, {  16,  60 }, {  15,  52 }, {  14,  60 },

  663.         {   3,  78 }, { -16, 123 }, {  21,  53 }, {  22,  56 },

  664.         {  25,  61 },

  665. 

  666.         /* 399 - 435 */

  667.         {  21,  33 }, {  19,  50 }, {  17,  61 },

  668.         {  -3,  78 }, {  -8,  74 }, {  -9,  72 }, { -10,  72 },

  669.         { -18,  75 }, { -12,  71 }, { -11,  63 }, {  -5,  70 },

  670.         { -17,  75 }, { -14,  72 }, { -16,  67 }, {  -8,  53 },

  671.         { -14,  59 }, {  -9,  52 }, { -11,  68 }, {   9,  -2 },

  672.         {  30, -10 }, {  31,  -4 }, {  33,  -1 }, {  33,   7 },

  673.         {  31,  12 }, {  37,  23 }, {  31,  38 }, {  20,  64 },

  674.         {  -9,  71 }, {  -7,  37 }, {  -8,  44 }, { -11,  49 },

  675.         { -10,  56 }, { -12,  59 }, {  -8,  63 }, {  -9,  67 },

  676.         {  -6,  68 }, { -10,  79 },

  677. 

  678.         /* 436 - 459 */

  679.         {  -3,  78 }, {  -8,  74 }, {  -9,  72 }, { -10,  72 },

  680.         { -18,  75 }, { -12,  71 }, { -11,  63 }, {  -5,  70 },

  681.         { -17,  75 }, { -14,  72 }, { -16,  67 }, {  -8,  53 },

  682.         { -14,  59 }, {  -9,  52 }, { -11,  68 }, {   9,  -2 },

  683.         {  30, -10 }, {  31,  -4 }, {  33,  -1 }, {  33,   7 },

  684.         {  31,  12 }, {  37,  23 }, {  31,  38 }, {  20,  64 },

  685.     }

  686. };

  687. 

  688. void ff_h264_init_cabac_states(H264Context *h) {

  689.     MpegEncContext * const s = &h->s;

  690.     int i;

  691. 

  692.     /* calculate pre-state */

  693.     for( i= 0; i < 460; i++ ) {

  694.         int pre;

  695.         if( h->slice_type_nos == FF_I_TYPE )

  696.             pre = av_clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 );

  697.         else

  698.             pre = av_clip( ((cabac_context_init_PB[h->cabac_init_idc][i][0] * s->qscale) >>4 ) + cabac_context_init_PB[h->cabac_init_idc][i][1], 1, 126 );

  699. 

  700.         if( pre <= 63 )

  701.             h->cabac_state[i] = 2 * ( 63 - pre ) + 0;

  702.         else

  703.             h->cabac_state[i] = 2 * ( pre - 64 ) + 1;

  704.     }

  705. }

  706. 

  707. static int decode_cabac_field_decoding_flag(H264Context *h) {

  708.     MpegEncContext * const s = &h->s;

  709.     const int mb_x = s->mb_x;

  710.     const int mb_y = s->mb_y & ~1;

  711.     const int mba_xy = mb_x - 1 +  mb_y   *s->mb_stride;

  712.     const int mbb_xy = mb_x     + (mb_y-2)*s->mb_stride;

  713. 

  714.     unsigned int ctx = 0;

  715. 

  716.     if( h->slice_table[mba_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) {

  717.         ctx += 1;

  718.     }

  719.     if( h->slice_table[mbb_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) {

  720.         ctx += 1;

  721.     }

  722. 

  723.     return get_cabac_noinline( &h->cabac, &h->cabac_state[70 + ctx] );

  724. }

  725. 

  726. static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {

  727.     uint8_t *state= &h->cabac_state[ctx_base];

  728.     int mb_type;

  729. 

  730.     if(intra_slice){

  731.         MpegEncContext * const s = &h->s;

  732.         const int mba_xy = h->left_mb_xy[0];

  733.         const int mbb_xy = h->top_mb_xy;

  734.         int ctx=0;

  735.         if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) )

  736.             ctx++;

  737.         if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) )

  738.             ctx++;

  739.         if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )

  740.             return 0;   /* I4x4 */

  741.         state += 2;

  742.     }else{

  743.         if( get_cabac_noinline( &h->cabac, state ) == 0 )

  744.             return 0;   /* I4x4 */

  745.     }

  746. 

  747.     if( get_cabac_terminate( &h->cabac ) )

  748.         return 25;  /* PCM */

  749. 

  750.     mb_type = 1; /* I16x16 */

  751.     mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */

  752.     if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */

  753.         mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] );

  754.     mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] );

  755.     mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] );

  756.     return mb_type;

  757. }

  758. 

  759. static int decode_cabac_mb_type_b( H264Context *h ) {

  760.     MpegEncContext * const s = &h->s;

  761. 

  762.         const int mba_xy = h->left_mb_xy[0];

  763.         const int mbb_xy = h->top_mb_xy;

  764.         int ctx = 0;

  765.         int bits;

  766.         assert(h->slice_type_nos == FF_B_TYPE);

  767. 

  768.         if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )

  769.             ctx++;

  770.         if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) )

  771.             ctx++;

  772. 

  773.         if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) )

  774.             return 0; /* B_Direct_16x16 */

  775. 

  776.         if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {

  777.             return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */

  778.         }

  779. 

  780.         bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;

  781.         bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;

  782.         bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;

  783.         bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );

  784.         if( bits < 8 )

  785.             return bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */

  786.         else if( bits == 13 ) {

  787.             return decode_cabac_intra_mb_type(h, 32, 0) + 23;

  788.         } else if( bits == 14 )

  789.             return 11; /* B_L1_L0_8x16 */

  790.         else if( bits == 15 )

  791.             return 22; /* B_8x8 */

  792. 

  793.         bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );

  794.         return bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */

  795. }

  796. 

  797. static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {

  798.     MpegEncContext * const s = &h->s;

  799.     int mba_xy, mbb_xy;

  800.     int ctx = 0;

  801. 

  802.     if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?

  803.         int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;

  804.         mba_xy = mb_xy - 1;

  805.         if( (mb_y&1)

  806.             && h->slice_table[mba_xy] == h->slice_num

  807.             && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )

  808.             mba_xy += s->mb_stride;

  809.         if( MB_FIELD ){

  810.             mbb_xy = mb_xy - s->mb_stride;

  811.             if( !(mb_y&1)

  812.                 && h->slice_table[mbb_xy] == h->slice_num

  813.                 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )

  814.                 mbb_xy -= s->mb_stride;

  815.         }else

  816.             mbb_xy = mb_x + (mb_y-1)*s->mb_stride;

  817.     }else{

  818.         int mb_xy = h->mb_xy;

  819.         mba_xy = mb_xy - 1;

  820.         mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);

  821.     }

  822. 

  823.     if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))

  824.         ctx++;

  825.     if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))

  826.         ctx++;

  827. 

  828.     if( h->slice_type_nos == FF_B_TYPE )

  829.         ctx += 13;

  830.     return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );

  831. }

  832. 

  833. static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {

  834.     int mode = 0;

  835. 

  836.     if( get_cabac( &h->cabac, &h->cabac_state[68] ) )

  837.         return pred_mode;

  838. 

  839.     mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );

  840.     mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );

  841.     mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );

  842. 

  843.     if( mode >= pred_mode )

  844.         return mode + 1;

  845.     else

  846.         return mode;

  847. }

  848. 

  849. static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {

  850.     const int mba_xy = h->left_mb_xy[0];

  851.     const int mbb_xy = h->top_mb_xy;

  852. 

  853.     int ctx = 0;

  854. 

  855.     /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */

  856.     if( h->slice_table[mba_xy] == h->slice_num && h->chroma_pred_mode_table[mba_xy] != 0 )

  857.         ctx++;

  858. 

  859.     if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )

  860.         ctx++;

  861. 

  862.     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )

  863.         return 0;

  864. 

  865.     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )

  866.         return 1;

  867.     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )

  868.         return 2;

  869.     else

  870.         return 3;

  871. }

  872. 

  873. static int decode_cabac_mb_cbp_luma( H264Context *h) {

  874.     int cbp_b, cbp_a, ctx, cbp = 0;

  875. 

  876.     cbp_a = h->slice_table[h->left_mb_xy[0]] == h->slice_num ? h->left_cbp : -1;

  877.     cbp_b = h->slice_table[h->top_mb_xy]     == h->slice_num ? h->top_cbp  : -1;

  878. 

  879.     ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);

  880.     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);

  881.     ctx = !(cbp   & 0x01) + 2 * !(cbp_b & 0x08);

  882.     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;

  883.     ctx = !(cbp_a & 0x08) + 2 * !(cbp   & 0x01);

  884.     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;

  885.     ctx = !(cbp   & 0x04) + 2 * !(cbp   & 0x02);

  886.     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;

  887.     return cbp;

  888. }

  889. static int decode_cabac_mb_cbp_chroma( H264Context *h) {

  890.     int ctx;

  891.     int cbp_a, cbp_b;

  892. 

  893.     cbp_a = (h->left_cbp>>4)&0x03;

  894.     cbp_b = (h-> top_cbp>>4)&0x03;

  895. 

  896.     ctx = 0;

  897.     if( cbp_a > 0 ) ctx++;

  898.     if( cbp_b > 0 ) ctx += 2;

  899.     if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )

  900.         return 0;

  901. 

  902.     ctx = 4;

  903.     if( cbp_a == 2 ) ctx++;

  904.     if( cbp_b == 2 ) ctx += 2;

  905.     return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );

  906. }

  907. static int decode_cabac_mb_dqp( H264Context *h) {

  908.     int   ctx= h->last_qscale_diff != 0;

  909.     int   val = 0;

  910. 

  911.     while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {

  912.         ctx= 2+(ctx>>1);

  913.         val++;

  914.         if(val > 102) //prevent infinite loop

  915.             return INT_MIN;

  916.     }

  917. 

  918.     if( val&0x01 )

  919.         return   (val + 1)>>1 ;

  920.     else

  921.         return -((val + 1)>>1);

  922. }

  923. static int decode_cabac_p_mb_sub_type( H264Context *h ) {

  924.     if( get_cabac( &h->cabac, &h->cabac_state[21] ) )

  925.         return 0;   /* 8x8 */

  926.     if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )

  927.         return 1;   /* 8x4 */

  928.     if( get_cabac( &h->cabac, &h->cabac_state[23] ) )

  929.         return 2;   /* 4x8 */

  930.     return 3;       /* 4x4 */

  931. }

  932. static int decode_cabac_b_mb_sub_type( H264Context *h ) {

  933.     int type;

  934.     if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )

  935.         return 0;   /* B_Direct_8x8 */

  936.     if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )

  937.         return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */

  938.     type = 3;

  939.     if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {

  940.         if( get_cabac( &h->cabac, &h->cabac_state[39] ) )

  941.             return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */

  942.         type += 4;

  943.     }

  944.     type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );

  945.     type +=   get_cabac( &h->cabac, &h->cabac_state[39] );

  946.     return type;

  947. }

  948. 

  949. static inline int decode_cabac_mb_transform_size( H264Context *h ) {

  950.     return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );

  951. }

  952. 

  953. static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {

  954.     int refa = h->ref_cache[list][scan8[n] - 1];

  955.     int refb = h->ref_cache[list][scan8[n] - 8];

  956.     int ref  = 0;

  957.     int ctx  = 0;

  958. 

  959.     if( h->slice_type_nos == FF_B_TYPE) {

  960.         if( refa > 0 && !h->direct_cache[scan8[n] - 1] )

  961.             ctx++;

  962.         if( refb > 0 && !h->direct_cache[scan8[n] - 8] )

  963.             ctx += 2;

  964.     } else {

  965.         if( refa > 0 )

  966.             ctx++;

  967.         if( refb > 0 )

  968.             ctx += 2;

  969.     }

  970. 

  971.     while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {

  972.         ref++;

  973.         ctx = (ctx>>2)+4;

  974.         if(ref >= 32 /*h->ref_list[list]*/){

  975.             return -1;

  976.         }

  977.     }

  978.     return ref;

  979. }

  980. 

  981. static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {

  982.     int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +

  983.                abs( h->mvd_cache[list][scan8[n] - 8][l] );

  984.     int ctxbase = (l == 0) ? 40 : 47;

  985.     int mvd;

  986.     int ctx = (amvd>2) + (amvd>32);

  987. 

  988.     if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))

  989.         return 0;

  990. 

  991.     mvd= 1;

  992.     ctx= 3;

  993.     while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {

  994.         mvd++;

  995.         if( ctx < 6 )

  996.             ctx++;

  997.     }

  998. 

  999.     if( mvd >= 9 ) {

  1000.         int k = 3;

  1001.         while( get_cabac_bypass( &h->cabac ) ) {

  1002.             mvd += 1 << k;

  1003.             k++;

  1004.             if(k>24){

  1005.                 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");

  1006.                 return INT_MIN;

  1007.             }

  1008.         }

  1009.         while( k-- ) {

  1010.             if( get_cabac_bypass( &h->cabac ) )

  1011.                 mvd += 1 << k;

  1012.         }

  1013.     }

  1014.     return get_cabac_bypass_sign( &h->cabac, -mvd );

  1015. }

  1016. 

  1017. static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {

  1018.     int nza, nzb;

  1019.     int ctx = 0;

  1020. 

  1021.     if( is_dc ) {

  1022.         if( cat == 0 ) {

  1023.             nza = h->left_cbp&0x100;

  1024.             nzb = h-> top_cbp&0x100;

  1025.         } else {

  1026.             nza = (h->left_cbp>>(6+idx))&0x01;

  1027.             nzb = (h-> top_cbp>>(6+idx))&0x01;

  1028.         }

  1029.     } else {

  1030.         assert(cat == 1 || cat == 2 || cat == 4);

  1031.         nza = h->non_zero_count_cache[scan8[idx] - 1];

  1032.         nzb = h->non_zero_count_cache[scan8[idx] - 8];

  1033.     }

  1034. 

  1035.     if( nza > 0 )

  1036.         ctx++;

  1037. 

  1038.     if( nzb > 0 )

  1039.         ctx += 2;

  1040. 

  1041.     return ctx + 4 * cat;

  1042. }

  1043. 

  1044. DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {

  1045.     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1046.     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  1047.     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,

  1048.     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8

  1049. };

  1050. 

  1051. static av_always_inline void decode_cabac_residual_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff, int is_dc ) {

  1052.     static const int significant_coeff_flag_offset[2][6] = {

  1053.       { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },

  1054.       { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }

  1055.     };

  1056.     static const int last_coeff_flag_offset[2][6] = {

  1057.       { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },

  1058.       { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }

  1059.     };

  1060.     static const int coeff_abs_level_m1_offset[6] = {

  1061.         227+0, 227+10, 227+20, 227+30, 227+39, 426

  1062.     };

  1063.     static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {

  1064.       { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,

  1065.         4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,

  1066.         7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,

  1067.        12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },

  1068.       { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,

  1069.         6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,

  1070.         9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,

  1071.         9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }

  1072.     };

  1073.     /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).

  1074.      * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).

  1075.      * map node ctx => cabac ctx for level=1 */

  1076.     static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };

  1077.     /* map node ctx => cabac ctx for level>1 */

  1078.     static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };

  1079.     static const uint8_t coeff_abs_level_transition[2][8] = {

  1080.     /* update node ctx after decoding a level=1 */

  1081.         { 1, 2, 3, 3, 4, 5, 6, 7 },

  1082.     /* update node ctx after decoding a level>1 */

  1083.         { 4, 4, 4, 4, 5, 6, 7, 7 }

  1084.     };

  1085. 

  1086.     int index[64];

  1087. 

  1088.     int av_unused last;

  1089.     int coeff_count = 0;

  1090.     int node_ctx = 0;

  1091. 

  1092.     uint8_t *significant_coeff_ctx_base;

  1093.     uint8_t *last_coeff_ctx_base;

  1094.     uint8_t *abs_level_m1_ctx_base;

  1095. 

  1096. #if !ARCH_X86

  1097. #define CABAC_ON_STACK

  1098. #endif

  1099. #ifdef CABAC_ON_STACK

  1100. #define CC &cc

  1101.     CABACContext cc;

  1102.     cc.range     = h->cabac.range;

  1103.     cc.low       = h->cabac.low;

  1104.     cc.bytestream= h->cabac.bytestream;

  1105. #else

  1106. #define CC &h->cabac

  1107. #endif

  1108. 

  1109. 

  1110.     /* cat: 0-> DC 16x16  n = 0

  1111.      *      1-> AC 16x16  n = luma4x4idx

  1112.      *      2-> Luma4x4   n = luma4x4idx

  1113.      *      3-> DC Chroma n = iCbCr

  1114.      *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx

  1115.      *      5-> Luma8x8   n = 4 * luma8x8idx

  1116.      */

  1117. 

  1118.     /* read coded block flag */

  1119.     if( is_dc || cat != 5 ) {

  1120.         if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {

  1121.             if( !is_dc )

  1122.                 h->non_zero_count_cache[scan8[n]] = 0;

  1123. 

  1124. #ifdef CABAC_ON_STACK

  1125.             h->cabac.range     = cc.range     ;

  1126.             h->cabac.low       = cc.low       ;

  1127.             h->cabac.bytestream= cc.bytestream;

  1128. #endif

  1129.             return;

  1130.         }

  1131.     }

  1132. 

  1133.     significant_coeff_ctx_base = h->cabac_state

  1134.         + significant_coeff_flag_offset[MB_FIELD][cat];

  1135.     last_coeff_ctx_base = h->cabac_state

  1136.         + last_coeff_flag_offset[MB_FIELD][cat];

  1137.     abs_level_m1_ctx_base = h->cabac_state

  1138.         + coeff_abs_level_m1_offset[cat];

  1139. 

  1140.     if( !is_dc && cat == 5 ) {

  1141. #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \

  1142.         for(last= 0; last < coefs; last++) { \

  1143.             uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \

  1144.             if( get_cabac( CC, sig_ctx )) { \

  1145.                 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \

  1146.                 index[coeff_count++] = last; \

  1147.                 if( get_cabac( CC, last_ctx ) ) { \

  1148.                     last= max_coeff; \

  1149.                     break; \

  1150.                 } \

  1151.             } \

  1152.         }\

  1153.         if( last == max_coeff -1 ) {\

  1154.             index[coeff_count++] = last;\

  1155.         }

  1156.         const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];

  1157. #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)

  1158.         coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);

  1159.     } else {

  1160.         coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);

  1161. #else

  1162.         DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );

  1163.     } else {

  1164.         DECODE_SIGNIFICANCE( max_coeff - 1, last, last );

  1165. #endif

  1166.     }

  1167.     assert(coeff_count > 0);

  1168. 

  1169.     if( is_dc ) {

  1170.         if( cat == 0 )

  1171.             h->cbp_table[h->mb_xy] |= 0x100;

  1172.         else

  1173.             h->cbp_table[h->mb_xy] |= 0x40 << n;

  1174.     } else {

  1175.         if( cat == 5 )

  1176.             fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);

  1177.         else {

  1178.             assert( cat == 1 || cat == 2 || cat == 4 );

  1179.             h->non_zero_count_cache[scan8[n]] = coeff_count;

  1180.         }

  1181.     }

  1182. 

  1183.     do {

  1184.         uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;

  1185. 

  1186.         int j= scantable[index[--coeff_count]];

  1187. 

  1188.         if( get_cabac( CC, ctx ) == 0 ) {

  1189.             node_ctx = coeff_abs_level_transition[0][node_ctx];

  1190.             if( is_dc ) {

  1191.                 block[j] = get_cabac_bypass_sign( CC, -1);

  1192.             }else{

  1193.                 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;

  1194.             }

  1195.         } else {

  1196.             int coeff_abs = 2;

  1197.             ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;

  1198.             node_ctx = coeff_abs_level_transition[1][node_ctx];

  1199. 

  1200.             while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {

  1201.                 coeff_abs++;

  1202.             }

  1203. 

  1204.             if( coeff_abs >= 15 ) {

  1205.                 int j = 0;

  1206.                 while( get_cabac_bypass( CC ) ) {

  1207.                     j++;

  1208.                 }

  1209. 

  1210.                 coeff_abs=1;

  1211.                 while( j-- ) {

  1212.                     coeff_abs += coeff_abs + get_cabac_bypass( CC );

  1213.                 }

  1214.                 coeff_abs+= 14;

  1215.             }

  1216. 

  1217.             if( is_dc ) {

  1218.                 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );

  1219.             }else{

  1220.                 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;

  1221.             }

  1222.         }

  1223.     } while( coeff_count );

  1224. #ifdef CABAC_ON_STACK

  1225.             h->cabac.range     = cc.range     ;

  1226.             h->cabac.low       = cc.low       ;

  1227.             h->cabac.bytestream= cc.bytestream;

  1228. #endif

  1229. 

  1230. }

  1231. 

  1232. #if !CONFIG_SMALL

  1233. static void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {

  1234.     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);

  1235. }

  1236. 

  1237. static void decode_cabac_residual_nondc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {

  1238.     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);

  1239. }

  1240. #endif

  1241. 

  1242. static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {

  1243. #if CONFIG_SMALL

  1244.     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);

  1245. #else

  1246.     if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);

  1247.     else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);

  1248. #endif

  1249. }

  1250. 

  1251. static inline void compute_mb_neighbors(H264Context *h)

  1252. {

  1253.     MpegEncContext * const s = &h->s;

  1254.     const int mb_xy  = h->mb_xy;

  1255.     h->top_mb_xy     = mb_xy - s->mb_stride;

  1256.     h->left_mb_xy[0] = mb_xy - 1;

  1257.     if(FRAME_MBAFF){

  1258.         const int pair_xy          = s->mb_x     + (s->mb_y & ~1)*s->mb_stride;

  1259.         const int top_pair_xy      = pair_xy     - s->mb_stride;

  1260.         const int top_mb_field_flag  = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);

  1261.         const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);

  1262.         const int curr_mb_field_flag = MB_FIELD;

  1263.         const int bottom = (s->mb_y & 1);

  1264. 

  1265.         if (curr_mb_field_flag && (bottom || top_mb_field_flag)){

  1266.             h->top_mb_xy -= s->mb_stride;

  1267.         }

  1268.         if (!left_mb_field_flag == curr_mb_field_flag) {

  1269.             h->left_mb_xy[0] = pair_xy - 1;

  1270.         }

  1271.     } else if (FIELD_PICTURE) {

  1272.         h->top_mb_xy -= s->mb_stride;

  1273.     }

  1274.     return;

  1275. }

  1276. 

  1277. /**

  1278.  * decodes a macroblock

  1279.  * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed

  1280.  */

  1281. int ff_h264_decode_mb_cabac(H264Context *h) {

  1282.     MpegEncContext * const s = &h->s;

  1283.     int mb_xy;

  1284.     int mb_type, partition_count, cbp = 0;

  1285.     int dct8x8_allowed= h->pps.transform_8x8_mode;

  1286. 

  1287.     mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;

  1288. 

  1289.     tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);

  1290.     if( h->slice_type_nos != FF_I_TYPE ) {

  1291.         int skip;

  1292.         /* a skipped mb needs the aff flag from the following mb */

  1293.         if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 )

  1294.             predict_field_decoding_flag(h);

  1295.         if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )

  1296.             skip = h->next_mb_skipped;

  1297.         else

  1298.             skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );

  1299.         /* read skip flags */

  1300.         if( skip ) {

  1301.             if( FRAME_MBAFF && (s->mb_y&1)==0 ){

  1302.                 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;

  1303.                 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );

  1304.                 if(!h->next_mb_skipped)

  1305.                     h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);

  1306.             }

  1307. 

  1308.             decode_mb_skip(h);

  1309. 

  1310.             h->cbp_table[mb_xy] = 0;

  1311.             h->chroma_pred_mode_table[mb_xy] = 0;

  1312.             h->last_qscale_diff = 0;

  1313. 

  1314.             return 0;

  1315. 

  1316.         }

  1317.     }

  1318.     if(FRAME_MBAFF){

  1319.         if( (s->mb_y&1) == 0 )

  1320.             h->mb_mbaff =

  1321.             h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);

  1322.     }

  1323. 

  1324.     h->prev_mb_skipped = 0;

  1325. 

  1326.     compute_mb_neighbors(h);

  1327. 

  1328.     if( h->slice_type_nos == FF_B_TYPE ) {

  1329.         mb_type = decode_cabac_mb_type_b( h );

  1330.         if( mb_type < 23 ){

  1331.             partition_count= b_mb_type_info[mb_type].partition_count;

  1332.             mb_type=         b_mb_type_info[mb_type].type;

  1333.         }else{

  1334.             mb_type -= 23;

  1335.             goto decode_intra_mb;

  1336.         }

  1337.     } else if( h->slice_type_nos == FF_P_TYPE ) {

  1338.         if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {

  1339.             /* P-type */

  1340.             if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {

  1341.                 /* P_L0_D16x16, P_8x8 */

  1342.                 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );

  1343.             } else {

  1344.                 /* P_L0_D8x16, P_L0_D16x8 */

  1345.                 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );

  1346.             }

  1347.             partition_count= p_mb_type_info[mb_type].partition_count;

  1348.             mb_type=         p_mb_type_info[mb_type].type;

  1349.         } else {

  1350.             mb_type= decode_cabac_intra_mb_type(h, 17, 0);

  1351.             goto decode_intra_mb;

  1352.         }

  1353.     } else {

  1354.         mb_type= decode_cabac_intra_mb_type(h, 3, 1);

  1355.         if(h->slice_type == FF_SI_TYPE && mb_type)

  1356.             mb_type--;

  1357.         assert(h->slice_type_nos == FF_I_TYPE);

  1358. decode_intra_mb:

  1359.         partition_count = 0;

  1360.         cbp= i_mb_type_info[mb_type].cbp;

  1361.         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;

  1362.         mb_type= i_mb_type_info[mb_type].type;

  1363.     }

  1364.     if(MB_FIELD)

  1365.         mb_type |= MB_TYPE_INTERLACED;

  1366. 

  1367.     h->slice_table[ mb_xy ]= h->slice_num;

  1368. 

  1369.     if(IS_INTRA_PCM(mb_type)) {

  1370.         const uint8_t *ptr;

  1371. 

  1372.         // We assume these blocks are very rare so we do not optimize it.

  1373.         // FIXME The two following lines get the bitstream position in the cabac

  1374.         // decode, I think it should be done by a function in cabac.h (or cabac.c).

  1375.         ptr= h->cabac.bytestream;

  1376.         if(h->cabac.low&0x1) ptr--;

  1377.         if(CABAC_BITS==16){

  1378.             if(h->cabac.low&0x1FF) ptr--;

  1379.         }

  1380. 

  1381.         // The pixels are stored in the same order as levels in h->mb array.

  1382.         memcpy(h->mb, ptr, 256); ptr+=256;

  1383.         if(CHROMA){

  1384.             memcpy(h->mb+128, ptr, 128); ptr+=128;

  1385.         }

  1386. 

  1387.         ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);

  1388. 

  1389.         // All blocks are present

  1390.         h->cbp_table[mb_xy] = 0x1ef;

  1391.         h->chroma_pred_mode_table[mb_xy] = 0;

  1392.         // In deblocking, the quantizer is 0

  1393.         s->current_picture.qscale_table[mb_xy]= 0;

  1394.         // All coeffs are present

  1395.         memset(h->non_zero_count[mb_xy], 16, 32);

  1396.         s->current_picture.mb_type[mb_xy]= mb_type;

  1397.         h->last_qscale_diff = 0;

  1398.         return 0;

  1399.     }

  1400. 

  1401.     if(MB_MBAFF){

  1402.         h->ref_count[0] <<= 1;

  1403.         h->ref_count[1] <<= 1;

  1404.     }

  1405. 

  1406.     fill_decode_caches(h, mb_type);

  1407. 

  1408.     if( IS_INTRA( mb_type ) ) {

  1409.         int i, pred_mode;

  1410.         if( IS_INTRA4x4( mb_type ) ) {

  1411.             if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) {

  1412.                 mb_type |= MB_TYPE_8x8DCT;

  1413.                 for( i = 0; i < 16; i+=4 ) {

  1414.                     int pred = pred_intra_mode( h, i );

  1415.                     int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );

  1416.                     fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );

  1417.                 }

  1418.             } else {

  1419.                 for( i = 0; i < 16; i++ ) {

  1420.                     int pred = pred_intra_mode( h, i );

  1421.                     h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );

  1422. 

  1423.                 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );

  1424.                 }

  1425.             }

  1426.             ff_h264_write_back_intra_pred_mode(h);

  1427.             if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;

  1428.         } else {

  1429.             h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );

  1430.             if( h->intra16x16_pred_mode < 0 ) return -1;

  1431.         }

  1432.         if(CHROMA){

  1433.             h->chroma_pred_mode_table[mb_xy] =

  1434.             pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );

  1435. 

  1436.             pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );

  1437.             if( pred_mode < 0 ) return -1;

  1438.             h->chroma_pred_mode= pred_mode;

  1439.         }

  1440.     } else if( partition_count == 4 ) {

  1441.         int i, j, sub_partition_count[4], list, ref[2][4];

  1442. 

  1443.         if( h->slice_type_nos == FF_B_TYPE ) {

  1444.             for( i = 0; i < 4; i++ ) {

  1445.                 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );

  1446.                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;

  1447.                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;

  1448.             }

  1449.             if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |

  1450.                           h->sub_mb_type[2] | h->sub_mb_type[3]) ) {

  1451.                 ff_h264_pred_direct_motion(h, &mb_type);

  1452.                 h->ref_cache[0][scan8[4]] =

  1453.                 h->ref_cache[1][scan8[4]] =

  1454.                 h->ref_cache[0][scan8[12]] =

  1455.                 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;

  1456.                 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) {

  1457.                     for( i = 0; i < 4; i++ )

  1458.                         if( IS_DIRECT(h->sub_mb_type[i]) )

  1459.                             fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 );

  1460.                 }

  1461.             }

  1462.         } else {

  1463.             for( i = 0; i < 4; i++ ) {

  1464.                 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );

  1465.                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;

  1466.                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;

  1467.             }

  1468.         }

  1469. 

  1470.         for( list = 0; list < h->list_count; list++ ) {

  1471.                 for( i = 0; i < 4; i++ ) {

  1472.                     if(IS_DIRECT(h->sub_mb_type[i])) continue;

  1473.                     if(IS_DIR(h->sub_mb_type[i], 0, list)){

  1474.                         if( h->ref_count[list] > 1 ){

  1475.                             ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );

  1476.                             if(ref[list][i] >= (unsigned)h->ref_count[list]){

  1477.                                 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);

  1478.                                 return -1;

  1479.                             }

  1480.                         }else

  1481.                             ref[list][i] = 0;

  1482.                     } else {

  1483.                         ref[list][i] = -1;

  1484.                     }

  1485.                                                        h->ref_cache[list][ scan8[4*i]+1 ]=

  1486.                     h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];

  1487.                 }

  1488.         }

  1489. 

  1490.         if(dct8x8_allowed)

  1491.             dct8x8_allowed = get_dct8x8_allowed(h);

  1492. 

  1493.         for(list=0; list<h->list_count; list++){

  1494.             for(i=0; i<4; i++){

  1495.                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];

  1496.                 if(IS_DIRECT(h->sub_mb_type[i])){

  1497.                     fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);

  1498.                     continue;

  1499.                 }

  1500. 

  1501.                 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){

  1502.                     const int sub_mb_type= h->sub_mb_type[i];

  1503.                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;

  1504.                     for(j=0; j<sub_partition_count[i]; j++){

  1505.                         int mpx, mpy;

  1506.                         int mx, my;

  1507.                         const int index= 4*i + block_width*j;

  1508.                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];

  1509.                         int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];

  1510.                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);

  1511. 

  1512.                         mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );

  1513.                         my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );

  1514.                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);

  1515. 

  1516.                         if(IS_SUB_8X8(sub_mb_type)){

  1517.                             mv_cache[ 1 ][0]=

  1518.                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;

  1519.                             mv_cache[ 1 ][1]=

  1520.                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;

  1521. 

  1522.                             mvd_cache[ 1 ][0]=

  1523.                             mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;

  1524.                             mvd_cache[ 1 ][1]=

  1525.                             mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;

  1526.                         }else if(IS_SUB_8X4(sub_mb_type)){

  1527.                             mv_cache[ 1 ][0]= mx;

  1528.                             mv_cache[ 1 ][1]= my;

  1529. 

  1530.                             mvd_cache[ 1 ][0]= mx - mpx;

  1531.                             mvd_cache[ 1 ][1]= my - mpy;

  1532.                         }else if(IS_SUB_4X8(sub_mb_type)){

  1533.                             mv_cache[ 8 ][0]= mx;

  1534.                             mv_cache[ 8 ][1]= my;

  1535. 

  1536.                             mvd_cache[ 8 ][0]= mx - mpx;

  1537.                             mvd_cache[ 8 ][1]= my - mpy;

  1538.                         }

  1539.                         mv_cache[ 0 ][0]= mx;

  1540.                         mv_cache[ 0 ][1]= my;

  1541. 

  1542.                         mvd_cache[ 0 ][0]= mx - mpx;

  1543.                         mvd_cache[ 0 ][1]= my - mpy;

  1544.                     }

  1545.                 }else{

  1546.                     uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];

  1547.                     uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];

  1548.                     p[0] = p[1] = p[8] = p[9] = 0;

  1549.                     pd[0]= pd[1]= pd[8]= pd[9]= 0;

  1550.                 }

  1551.             }

  1552.         }

  1553.     } else if( IS_DIRECT(mb_type) ) {

  1554.         ff_h264_pred_direct_motion(h, &mb_type);

  1555.         fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);

  1556.         fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);

  1557.         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;

  1558.     } else {

  1559.         int list, mx, my, i, mpx, mpy;

  1560.         if(IS_16X16(mb_type)){

  1561.             for(list=0; list<h->list_count; list++){

  1562.                 if(IS_DIR(mb_type, 0, list)){

  1563.                     int ref;

  1564.                     if(h->ref_count[list] > 1){

  1565.                         ref= decode_cabac_mb_ref(h, list, 0);

  1566.                         if(ref >= (unsigned)h->ref_count[list]){

  1567.                             av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);

  1568.                             return -1;

  1569.                         }

  1570.                     }else

  1571.                         ref=0;

  1572.                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);

  1573.                 }else

  1574.                     fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); //FIXME factorize and the other fill_rect below too

  1575.             }

  1576.             for(list=0; list<h->list_count; list++){

  1577.                 if(IS_DIR(mb_type, 0, list)){

  1578.                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);

  1579. 

  1580.                     mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );

  1581.                     my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );

  1582.                     tprintf(s->avctx, "final mv:%d %d\n", mx, my);

  1583. 

  1584.                     fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4);

  1585.                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);

  1586.                 }else

  1587.                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);

  1588.             }

  1589.         }

  1590.         else if(IS_16X8(mb_type)){

  1591.             for(list=0; list<h->list_count; list++){

  1592.                     for(i=0; i<2; i++){

  1593.                         if(IS_DIR(mb_type, i, list)){

  1594.                             int ref;

  1595.                             if(h->ref_count[list] > 1){

  1596.                                 ref= decode_cabac_mb_ref( h, list, 8*i );

  1597.                                 if(ref >= (unsigned)h->ref_count[list]){

  1598.                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);

  1599.                                     return -1;

  1600.                                 }

  1601.                             }else

  1602.                                 ref=0;

  1603.                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);

  1604.                         }else

  1605.                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);

  1606.                     }

  1607.             }

  1608.             for(list=0; list<h->list_count; list++){

  1609.                 for(i=0; i<2; i++){

  1610.                     if(IS_DIR(mb_type, i, list)){

  1611.                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);

  1612.                         mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );

  1613.                         my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );

  1614.                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);

  1615. 

  1616.                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);

  1617.                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);

  1618.                     }else{

  1619.                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);

  1620.                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);

  1621.                     }

  1622.                 }

  1623.             }

  1624.         }else{

  1625.             assert(IS_8X16(mb_type));

  1626.             for(list=0; list<h->list_count; list++){

  1627.                     for(i=0; i<2; i++){

  1628.                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize

  1629.                             int ref;

  1630.                             if(h->ref_count[list] > 1){

  1631.                                 ref= decode_cabac_mb_ref( h, list, 4*i );

  1632.                                 if(ref >= (unsigned)h->ref_count[list]){

  1633.                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);

  1634.                                     return -1;

  1635.                                 }

  1636.                             }else

  1637.                                 ref=0;

  1638.                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);

  1639.                         }else

  1640.                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);

  1641.                     }

  1642.             }

  1643.             for(list=0; list<h->list_count; list++){

  1644.                 for(i=0; i<2; i++){

  1645.                     if(IS_DIR(mb_type, i, list)){

  1646.                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);

  1647.                         mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );

  1648.                         my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );

  1649. 

  1650.                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);

  1651.                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);

  1652.                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);

  1653.                     }else{

  1654.                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);

  1655.                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);

  1656.                     }

  1657.                 }

  1658.             }

  1659.         }

  1660.     }

  1661. 

  1662.    if( IS_INTER( mb_type ) ) {

  1663.         h->chroma_pred_mode_table[mb_xy] = 0;

  1664.         write_back_motion( h, mb_type );

  1665.    }

  1666. 

  1667.     if( !IS_INTRA16x16( mb_type ) ) {

  1668.         cbp  = decode_cabac_mb_cbp_luma( h );

  1669.         if(CHROMA)

  1670.             cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;

  1671.     }

  1672. 

  1673.     h->cbp_table[mb_xy] = h->cbp = cbp;

  1674. 

  1675.     if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {

  1676.         if( decode_cabac_mb_transform_size( h ) )

  1677.             mb_type |= MB_TYPE_8x8DCT;

  1678.     }

  1679.     s->current_picture.mb_type[mb_xy]= mb_type;

  1680. 

  1681.     if( cbp || IS_INTRA16x16( mb_type ) ) {

  1682.         const uint8_t *scan, *scan8x8, *dc_scan;

  1683.         const uint32_t *qmul;

  1684.         int dqp;

  1685. 

  1686.         if(IS_INTERLACED(mb_type)){

  1687.             scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;

  1688.             scan= s->qscale ? h->field_scan : h->field_scan_q0;

  1689.             dc_scan= luma_dc_field_scan;

  1690.         }else{

  1691.             scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;

  1692.             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;

  1693.             dc_scan= luma_dc_zigzag_scan;

  1694.         }

  1695. 

  1696.         h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h );

  1697.         if( dqp == INT_MIN ){

  1698.             av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);

  1699.             return -1;

  1700.         }

  1701.         s->qscale += dqp;

  1702.         if(((unsigned)s->qscale) > 51){

  1703.             if(s->qscale<0) s->qscale+= 52;

  1704.             else            s->qscale-= 52;

  1705.         }

  1706.         h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);

  1707.         h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);

  1708. 

  1709.         if( IS_INTRA16x16( mb_type ) ) {

  1710.             int i;

  1711.             //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );

  1712.             decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);

  1713. 

  1714.             if( cbp&15 ) {

  1715.                 qmul = h->dequant4_coeff[0][s->qscale];

  1716.                 for( i = 0; i < 16; i++ ) {

  1717.                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );

  1718.                     decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);

  1719.                 }

  1720.             } else {

  1721.                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);

  1722.             }

  1723.         } else {

  1724.             int i8x8, i4x4;

  1725.             for( i8x8 = 0; i8x8 < 4; i8x8++ ) {

  1726.                 if( cbp & (1<<i8x8) ) {

  1727.                     if( IS_8x8DCT(mb_type) ) {

  1728.                         decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,

  1729.                             scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);

  1730.                     } else {

  1731.                         qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];

  1732.                         for( i4x4 = 0; i4x4 < 4; i4x4++ ) {

  1733.                             const int index = 4*i8x8 + i4x4;

  1734.                             //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );

  1735. //START_TIMER

  1736.                             decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);

  1737. //STOP_TIMER("decode_residual")

  1738.                         }

  1739.                     }

  1740.                 } else {

  1741.                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];

  1742.                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;

  1743.                 }

  1744.             }

  1745.         }

  1746. 

  1747.         if( cbp&0x30 ){

  1748.             int c;

  1749.             for( c = 0; c < 2; c++ ) {

  1750.                 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );

  1751.                 decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);

  1752.             }

  1753.         }

  1754. 

  1755.         if( cbp&0x20 ) {

  1756.             int c, i;

  1757.             for( c = 0; c < 2; c++ ) {

  1758.                 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];

  1759.                 for( i = 0; i < 4; i++ ) {

  1760.                     const int index = 16 + 4 * c + i;

  1761.                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );

  1762.                     decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);

  1763.                 }

  1764.             }

  1765.         } else {

  1766.             uint8_t * const nnz= &h->non_zero_count_cache[0];

  1767.             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =

  1768.             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;

  1769.         }

  1770.     } else {

  1771.         uint8_t * const nnz= &h->non_zero_count_cache[0];

  1772.         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);

  1773.         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =

  1774.         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;

  1775.         h->last_qscale_diff = 0;

  1776.     }

  1777. 

  1778.     s->current_picture.qscale_table[mb_xy]= s->qscale;

  1779.     write_back_non_zero_count(h);

  1780. 

  1781.     if(MB_MBAFF){

  1782.         h->ref_count[0] >>= 1;

  1783.         h->ref_count[1] >>= 1;

  1784.     }

  1785. 

  1786.     return 0;

  1787. }