开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
h264.c
资源名称：ffh264lib_ffmpeg-r16537_2009(fast64bits).zip　[点击查看]
上传用户：chinavct
上传日期：2022-06-20
资源大小：330k
文件大小：325k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

h264.c：源码内容
  1.         if(i[1] < len){
  2.             in[ i[1] ]->pic_id= is_long ? i[1] : in[ i[1] ]->frame_num;
  3.             split_field_copy(&def[index++], in[ i[1]++ ], sel^3, 0);
  4.         }
  5.     }
  7.     return index;
  8. }
  10. static int add_sorted(Picture **sorted, Picture **src, int len, int limit, int dir){
  11.     int i, best_poc;
  12.     int out_i= 0;
  14.     for(;;){
  15.         best_poc= dir ? INT_MIN : INT_MAX;
  17.         for(i=0; i<len; i++){
  18.             const int poc= src[i]->poc;
  19.             if(((poc > limit) ^ dir) && ((poc < best_poc) ^ dir)){
  20.                 best_poc= poc;
  21.                 sorted[out_i]= src[i];
  22.             }
  23.         }
  24.         if(best_poc == (dir ? INT_MIN : INT_MAX))
  25.             break;
  26.         limit= sorted[out_i++]->poc - dir;
  27.     }
  28.     return out_i;
  29. }
  31. /**
  32.  * fills the default_ref_list.
  33.  */
  34. static int fill_default_ref_list(H264Context *h){
  35.     MpegEncContext * const s = &h->s;
  36.     int i, len;
  38.     if(h->slice_type_nos==FF_B_TYPE){
  39.         Picture *sorted[32];
  40.         int cur_poc, list;
  41.         int lens[2];
  43.         if(FIELD_PICTURE)
  44.             cur_poc= s->current_picture_ptr->field_poc[ s->picture_structure == PICT_BOTTOM_FIELD ];
  45.         else
  46.             cur_poc= s->current_picture_ptr->poc;
  48.         for(list= 0; list<2; list++){
  49.             len= add_sorted(sorted    , h->short_ref, h->short_ref_count, cur_poc, 1^list);
  50.             len+=add_sorted(sorted+len, h->short_ref, h->short_ref_count, cur_poc, 0^list);
  51.             assert(len<=32);
  52.             len= build_def_list(h->default_ref_list[list]    , sorted     , len, 0, s->picture_structure);
  53.             len+=build_def_list(h->default_ref_list[list]+len, h->long_ref, 16 , 1, s->picture_structure);
  54.             assert(len<=32);
  56.             if(len < h->ref_count[list])
  57.                 memset(&h->default_ref_list[list][len], 0, sizeof(Picture)*(h->ref_count[list] - len));
  58.             lens[list]= len;
  59.         }
  61.         if(lens[0] == lens[1] && lens[1] > 1){
  62.             for(i=0; h->default_ref_list[0][i].data[0] == h->default_ref_list[1][i].data[0] && i<lens[0]; i++);
  63.             if(i == lens[0])
  64.                 FFSWAP(Picture, h->default_ref_list[1][0], h->default_ref_list[1][1]);
  65.         }
  66.     }else{
  67.         len = build_def_list(h->default_ref_list[0]    , h->short_ref, h->short_ref_count, 0, s->picture_structure);
  68.         len+= build_def_list(h->default_ref_list[0]+len, h-> long_ref, 16                , 1, s->picture_structure);
  69.         assert(len <= 32);
  70.         if(len < h->ref_count[0])
  71.             memset(&h->default_ref_list[0][len], 0, sizeof(Picture)*(h->ref_count[0] - len));
  72.     }
  73. #ifdef TRACE
  74.     for (i=0; i<h->ref_count[0]; i++) {
  75.         tprintf(h->s.avctx, "List0: %s fn:%d 0x%pn", (h->default_ref_list[0][i].long_ref ? "LT" : "ST"), h->default_ref_list[0][i].pic_id, h->default_ref_list[0][i].data[0]);
  76.     }
  77.     if(h->slice_type_nos==FF_B_TYPE){
  78.         for (i=0; i<h->ref_count[1]; i++) {
  79.             tprintf(h->s.avctx, "List1: %s fn:%d 0x%pn", (h->default_ref_list[1][i].long_ref ? "LT" : "ST"), h->default_ref_list[1][i].pic_id, h->default_ref_list[1][i].data[0]);
  80.         }
  81.     }
  82. #endif
  83.     return 0;
  84. }
  86. static void print_short_term(H264Context *h);
  87. static void print_long_term(H264Context *h);
  89. /**
  90.  * Extract structure information about the picture described by pic_num in
  91.  * the current decoding context (frame or field). Note that pic_num is
  92.  * picture number without wrapping (so, 0<=pic_num<max_pic_num).
  93.  * @param pic_num picture number for which to extract structure information
  94.  * @param structure one of PICT_XXX describing structure of picture
  95.  *                      with pic_num
  96.  * @return frame number (short term) or long term index of picture
  97.  *         described by pic_num
  98.  */
  99. static int pic_num_extract(H264Context *h, int pic_num, int *structure){
  100.     MpegEncContext * const s = &h->s;
  102.     *structure = s->picture_structure;
  103.     if(FIELD_PICTURE){
  104.         if (!(pic_num & 1))
  105.             /* opposite field */
  106.             *structure ^= PICT_FRAME;
  107.         pic_num >>= 1;
  108.     }
  110.     return pic_num;
  111. }
  113. static int decode_ref_pic_list_reordering(H264Context *h){
  114.     MpegEncContext * const s = &h->s;
  115.     int list, index, pic_structure;
  117.     print_short_term(h);
  118.     print_long_term(h);
  120.     for(list=0; list<h->list_count; list++){
  121.         memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]);
  123.         if(get_bits1(&s->gb)){
  124.             int pred= h->curr_pic_num;
  126.             for(index=0; ; index++){
  127.                 unsigned int reordering_of_pic_nums_idc= get_ue_golomb_31(&s->gb);
  128.                 unsigned int pic_id;
  129.                 int i;
  130.                 Picture *ref = NULL;
  132.                 if(reordering_of_pic_nums_idc==3)
  133.                     break;
  135.                 if(index >= h->ref_count[list]){
  136.                     av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflown");
  137.                     return -1;
  138.                 }
  140.                 if(reordering_of_pic_nums_idc<3){
  141.                     if(reordering_of_pic_nums_idc<2){
  142.                         const unsigned int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1;
  143.                         int frame_num;
  145.                         if((int)abs_diff_pic_num > h->max_pic_num){
  146.                             av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflown");
  147.                             return -1;
  148.                         }
  150.                         if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num;
  151.                         else                                pred+= abs_diff_pic_num;
  152.                         pred &= h->max_pic_num - 1;
  154.                         frame_num = pic_num_extract(h, pred, &pic_structure);
  156.                         for(i= h->short_ref_count-1; i>=0; i--){
  157.                             ref = h->short_ref[i];
  158.                             assert(ref->reference);
  159.                             assert(!ref->long_ref);
  160.                             if(
  161.                                    ref->frame_num == frame_num &&
  162.                                    (ref->reference & pic_structure)
  163.                               )
  164.                                 break;
  165.                         }
  166.                         if(i>=0)
  167.                             ref->pic_id= pred;
  168.                     }else{
  169.                         int long_idx;
  170.                         pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx
  172.                         long_idx= pic_num_extract(h, pic_id, &pic_structure);
  174.                         if(long_idx>31){
  175.                             av_log(h->s.avctx, AV_LOG_ERROR, "long_term_pic_idx overflown");
  176.                             return -1;
  177.                         }
  178.                         ref = h->long_ref[long_idx];
  179.                         assert(!(ref && !ref->reference));
  180.                         if(ref && (ref->reference & pic_structure)){
  181.                             ref->pic_id= pic_id;
  182.                             assert(ref->long_ref);
  183.                             i=0;
  184.                         }else{
  185.                             i=-1;
  186.                         }
  187.                     }
  189.                     if (i < 0) {
  190.                         av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reordern");
  191.                         memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME
  192.                     } else {
  193.                         for(i=index; i+1<h->ref_count[list]; i++){
  194.                             if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id)
  195.                                 break;
  196.                         }
  197.                         for(; i > index; i--){
  198.                             h->ref_list[list][i]= h->ref_list[list][i-1];
  199.                         }
  200.                         h->ref_list[list][index]= *ref;
  201.                         if (FIELD_PICTURE){
  202.                             pic_as_field(&h->ref_list[list][index], pic_structure);
  203.                         }
  204.                     }
  205.                 }else{
  206.                     av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idcn");
  207.                     return -1;
  208.                 }
  209.             }
  210.         }
  211.     }
  212.     for(list=0; list<h->list_count; list++){
  213.         for(index= 0; index < h->ref_count[list]; index++){
  214.             if(!h->ref_list[list][index].data[0]){
  215.                 av_log(h->s.avctx, AV_LOG_ERROR, "Missing reference picturen");
  216.                 h->ref_list[list][index]= s->current_picture; //FIXME this is not a sensible solution
  217.             }
  218.         }
  219.     }
  221.     return 0;
  222. }
  224. static void fill_mbaff_ref_list(H264Context *h){
  225.     int list, i, j;
  226.     for(list=0; list<2; list++){ //FIXME try list_count
  227.         for(i=0; i<h->ref_count[list]; i++){
  228.             Picture *frame = &h->ref_list[list][i];
  229.             Picture *field = &h->ref_list[list][16+2*i];
  230.             field[0] = *frame;
  231.             for(j=0; j<3; j++)
  232.                 field[0].linesize[j] <<= 1;
  233.             field[0].reference = PICT_TOP_FIELD;
  234.             field[0].poc= field[0].field_poc[0];
  235.             field[1] = field[0];
  236.             for(j=0; j<3; j++)
  237.                 field[1].data[j] += frame->linesize[j];
  238.             field[1].reference = PICT_BOTTOM_FIELD;
  239.             field[1].poc= field[1].field_poc[1];
  241.             h->luma_weight[list][16+2*i] = h->luma_weight[list][16+2*i+1] = h->luma_weight[list][i];
  242.             h->luma_offset[list][16+2*i] = h->luma_offset[list][16+2*i+1] = h->luma_offset[list][i];
  243.             for(j=0; j<2; j++){
  244.                 h->chroma_weight[list][16+2*i][j] = h->chroma_weight[list][16+2*i+1][j] = h->chroma_weight[list][i][j];
  245.                 h->chroma_offset[list][16+2*i][j] = h->chroma_offset[list][16+2*i+1][j] = h->chroma_offset[list][i][j];
  246.             }
  247.         }
  248.     }
  249.     for(j=0; j<h->ref_count[1]; j++){
  250.         for(i=0; i<h->ref_count[0]; i++)
  251.             h->implicit_weight[j][16+2*i] = h->implicit_weight[j][16+2*i+1] = h->implicit_weight[j][i];
  252.         memcpy(h->implicit_weight[16+2*j],   h->implicit_weight[j], sizeof(*h->implicit_weight));
  253.         memcpy(h->implicit_weight[16+2*j+1], h->implicit_weight[j], sizeof(*h->implicit_weight));
  254.     }
  255. }
  257. static int pred_weight_table(H264Context *h){
  258.     MpegEncContext * const s = &h->s;
  259.     int list, i;
  260.     int luma_def, chroma_def;
  262.     h->use_weight= 0;
  263.     h->use_weight_chroma= 0;
  264.     h->luma_log2_weight_denom= get_ue_golomb(&s->gb);
  265.     h->chroma_log2_weight_denom= get_ue_golomb(&s->gb);
  266.     luma_def = 1<<h->luma_log2_weight_denom;
  267.     chroma_def = 1<<h->chroma_log2_weight_denom;
  269.     for(list=0; list<2; list++){
  270.         for(i=0; i<h->ref_count[list]; i++){
  271.             int luma_weight_flag, chroma_weight_flag;
  273.             luma_weight_flag= get_bits1(&s->gb);
  274.             if(luma_weight_flag){
  275.                 h->luma_weight[list][i]= get_se_golomb(&s->gb);
  276.                 h->luma_offset[list][i]= get_se_golomb(&s->gb);
  277.                 if(   h->luma_weight[list][i] != luma_def
  278.                    || h->luma_offset[list][i] != 0)
  279.                     h->use_weight= 1;
  280.             }else{
  281.                 h->luma_weight[list][i]= luma_def;
  282.                 h->luma_offset[list][i]= 0;
  283.             }
  285.             if(CHROMA){
  286.                 chroma_weight_flag= get_bits1(&s->gb);
  287.                 if(chroma_weight_flag){
  288.                     int j;
  289.                     for(j=0; j<2; j++){
  290.                         h->chroma_weight[list][i][j]= get_se_golomb(&s->gb);
  291.                         h->chroma_offset[list][i][j]= get_se_golomb(&s->gb);
  292.                         if(   h->chroma_weight[list][i][j] != chroma_def
  293.                         || h->chroma_offset[list][i][j] != 0)
  294.                             h->use_weight_chroma= 1;
  295.                     }
  296.                 }else{
  297.                     int j;
  298.                     for(j=0; j<2; j++){
  299.                         h->chroma_weight[list][i][j]= chroma_def;
  300.                         h->chroma_offset[list][i][j]= 0;
  301.                     }
  302.                 }
  303.             }
  304.         }
  305.         if(h->slice_type_nos != FF_B_TYPE) break;
  306.     }
  307.     h->use_weight= h->use_weight || h->use_weight_chroma;
  308.     return 0;
  309. }
  311. static void implicit_weight_table(H264Context *h){
  312.     MpegEncContext * const s = &h->s;
  313.     int ref0, ref1;
  314.     int cur_poc = s->current_picture_ptr->poc;
  316.     if(   h->ref_count[0] == 1 && h->ref_count[1] == 1
  317.        && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){
  318.         h->use_weight= 0;
  319.         h->use_weight_chroma= 0;
  320.         return;
  321.     }
  323.     h->use_weight= 2;
  324.     h->use_weight_chroma= 2;
  325.     h->luma_log2_weight_denom= 5;
  326.     h->chroma_log2_weight_denom= 5;
  328.     for(ref0=0; ref0 < h->ref_count[0]; ref0++){
  329.         int poc0 = h->ref_list[0][ref0].poc;
  330.         for(ref1=0; ref1 < h->ref_count[1]; ref1++){
  331.             int poc1 = h->ref_list[1][ref1].poc;
  332.             int td = av_clip(poc1 - poc0, -128, 127);
  333.             if(td){
  334.                 int tb = av_clip(cur_poc - poc0, -128, 127);
  335.                 int tx = (16384 + (FFABS(td) >> 1)) / td;
  336.                 int dist_scale_factor = av_clip((tb*tx + 32) >> 6, -1024, 1023) >> 2;
  337.                 if(dist_scale_factor < -64 || dist_scale_factor > 128)
  338.                     h->implicit_weight[ref0][ref1] = 32;
  339.                 else
  340.                     h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor;
  341.             }else
  342.                 h->implicit_weight[ref0][ref1] = 32;
  343.         }
  344.     }
  345. }
  347. /**
  348.  * Mark a picture as no longer needed for reference. The refmask
  349.  * argument allows unreferencing of individual fields or the whole frame.
  350.  * If the picture becomes entirely unreferenced, but is being held for
  351.  * display purposes, it is marked as such.
  352.  * @param refmask mask of fields to unreference; the mask is bitwise
  353.  *                anded with the reference marking of pic
  354.  * @return non-zero if pic becomes entirely unreferenced (except possibly
  355.  *         for display purposes) zero if one of the fields remains in
  356.  *         reference
  357.  */
  358. static inline int unreference_pic(H264Context *h, Picture *pic, int refmask){
  359.     int i;
  360.     if (pic->reference &= refmask) {
  361.         return 0;
  362.     } else {
  363.         for(i = 0; h->delayed_pic[i]; i++)
  364.             if(pic == h->delayed_pic[i]){
  365.                 pic->reference=DELAYED_PIC_REF;
  366.                 break;
  367.             }
  368.         return 1;
  369.     }
  370. }
  372. /**
  373.  * instantaneous decoder refresh.
  374.  */
  375. static void idr(H264Context *h){
  376.     int i;
  378.     for(i=0; i<16; i++){
  379.         remove_long(h, i, 0);
  380.     }
  381.     assert(h->long_ref_count==0);
  383.     for(i=0; i<h->short_ref_count; i++){
  384.         unreference_pic(h, h->short_ref[i], 0);
  385.         h->short_ref[i]= NULL;
  386.     }
  387.     h->short_ref_count=0;
  388.     h->prev_frame_num= 0;
  389.     h->prev_frame_num_offset= 0;
  390.     h->prev_poc_msb=
  391.     h->prev_poc_lsb= 0;
  392. }
  394. /* forget old pics after a seek */
  395. static void flush_dpb(AVCodecContext *avctx){
  396.     H264Context *h= avctx->priv_data;
  397.     int i;
  398.     for(i=0; i<MAX_DELAYED_PIC_COUNT; i++) {
  399.         if(h->delayed_pic[i])
  400.             h->delayed_pic[i]->reference= 0;
  401.         h->delayed_pic[i]= NULL;
  402.     }
  403.     h->outputed_poc= INT_MIN;
  404.     idr(h);
  405.     if(h->s.current_picture_ptr)
  406.         h->s.current_picture_ptr->reference= 0;
  407.     h->s.first_field= 0;
  408.     ff_mpeg_flush(avctx);
  409. }
  411. /**
  412.  * Find a Picture in the short term reference list by frame number.
  413.  * @param frame_num frame number to search for
  414.  * @param idx the index into h->short_ref where returned picture is found
  415.  *            undefined if no picture found.
  416.  * @return pointer to the found picture, or NULL if no pic with the provided
  417.  *                 frame number is found
  418.  */
  419. static Picture * find_short(H264Context *h, int frame_num, int *idx){
  420.     MpegEncContext * const s = &h->s;
  421.     int i;
  423.     for(i=0; i<h->short_ref_count; i++){
  424.         Picture *pic= h->short_ref[i];
  425.         if(s->avctx->debug&FF_DEBUG_MMCO)
  426.             av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %pn", i, pic->frame_num, pic);
  427.         if(pic->frame_num == frame_num) {
  428.             *idx = i;
  429.             return pic;
  430.         }
  431.     }
  432.     return NULL;
  433. }
  435. /**
  436.  * Remove a picture from the short term reference list by its index in
  437.  * that list.  This does no checking on the provided index; it is assumed
  438.  * to be valid. Other list entries are shifted down.
  439.  * @param i index into h->short_ref of picture to remove.
  440.  */
  441. static void remove_short_at_index(H264Context *h, int i){
  442.     assert(i >= 0 && i < h->short_ref_count);
  443.     h->short_ref[i]= NULL;
  444.     if (--h->short_ref_count)
  445.         memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i)*sizeof(Picture*));
  446. }
  448. /**
  449.  *
  450.  * @return the removed picture or NULL if an error occurs
  451.  */
  452. static Picture * remove_short(H264Context *h, int frame_num, int ref_mask){
  453.     MpegEncContext * const s = &h->s;
  454.     Picture *pic;
  455.     int i;
  457.     if(s->avctx->debug&FF_DEBUG_MMCO)
  458.         av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %dn", frame_num, h->short_ref_count);
  460.     pic = find_short(h, frame_num, &i);
  461.     if (pic){
  462.         if(unreference_pic(h, pic, ref_mask))
  463.         remove_short_at_index(h, i);
  464.     }
  466.     return pic;
  467. }
  469. /**
  470.  * Remove a picture from the long term reference list by its index in
  471.  * that list.
  472.  * @return the removed picture or NULL if an error occurs
  473.  */
  474. static Picture * remove_long(H264Context *h, int i, int ref_mask){
  475.     Picture *pic;
  477.     pic= h->long_ref[i];
  478.     if (pic){
  479.         if(unreference_pic(h, pic, ref_mask)){
  480.             assert(h->long_ref[i]->long_ref == 1);
  481.             h->long_ref[i]->long_ref= 0;
  482.             h->long_ref[i]= NULL;
  483.             h->long_ref_count--;
  484.         }
  485.     }
  487.     return pic;
  488. }
  490. /**
  491.  * print short term list
  492.  */
  493. static void print_short_term(H264Context *h) {
  494.     int32_t i;
  495.     if(h->s.avctx->debug&FF_DEBUG_MMCO) {
  496.         av_log(h->s.avctx, AV_LOG_DEBUG, "short term list:n");
  497.         for(i=0; i<h->short_ref_count; i++){
  498.             Picture *pic= h->short_ref[i];
  499.             av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %pn", i, pic->frame_num, pic->poc, pic->data[0]);
  500.         }
  501.     }
  502. }
  504. /**
  505.  * print long term list
  506.  */
  507. static void print_long_term(H264Context *h) {
  508.     uint32_t i;
  509.     if(h->s.avctx->debug&FF_DEBUG_MMCO) {
  510.         av_log(h->s.avctx, AV_LOG_DEBUG, "long term list:n");
  511.         for(i = 0; i < 16; i++){
  512.             Picture *pic= h->long_ref[i];
  513.             if (pic) {
  514.                 av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %pn", i, pic->frame_num, pic->poc, pic->data[0]);
  515.             }
  516.         }
  517.     }
  518. }
  520. /**
  521.  * Executes the reference picture marking (memory management control operations).
  522.  */
  523. static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){
  524.     MpegEncContext * const s = &h->s;
  525.     int i, j;
  526.     int current_ref_assigned=0;
  527.     Picture *pic;
  529.     if((s->avctx->debug&FF_DEBUG_MMCO) && mmco_count==0)
  530.         av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco heren");
  532.     for(i=0; i<mmco_count; i++){
  533.         int structure, frame_num;
  534.         if(s->avctx->debug&FF_DEBUG_MMCO)
  535.             av_log(h->s.avctx, AV_LOG_DEBUG, "mmco:%d %d %dn", h->mmco[i].opcode, h->mmco[i].short_pic_num, h->mmco[i].long_arg);
  537.         if(   mmco[i].opcode == MMCO_SHORT2UNUSED
  538.            || mmco[i].opcode == MMCO_SHORT2LONG){
  539.             frame_num = pic_num_extract(h, mmco[i].short_pic_num, &structure);
  540.             pic = find_short(h, frame_num, &j);
  541.             if(!pic){
  542.                 if(mmco[i].opcode != MMCO_SHORT2LONG || !h->long_ref[mmco[i].long_arg]
  543.                    || h->long_ref[mmco[i].long_arg]->frame_num != frame_num)
  544.                 av_log(h->s.avctx, AV_LOG_ERROR, "mmco: unref short failuren");
  545.                 continue;
  546.             }
  547.         }
  549.         switch(mmco[i].opcode){
  550.         case MMCO_SHORT2UNUSED:
  551.             if(s->avctx->debug&FF_DEBUG_MMCO)
  552.                 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: unref short %d count %dn", h->mmco[i].short_pic_num, h->short_ref_count);
  553.             remove_short(h, frame_num, structure ^ PICT_FRAME);
  554.             break;
  555.         case MMCO_SHORT2LONG:
  556.                 if (h->long_ref[mmco[i].long_arg] != pic)
  557.                     remove_long(h, mmco[i].long_arg, 0);
  559.                 remove_short_at_index(h, j);
  560.                 h->long_ref[ mmco[i].long_arg ]= pic;
  561.                 if (h->long_ref[ mmco[i].long_arg ]){
  562.                     h->long_ref[ mmco[i].long_arg ]->long_ref=1;
  563.                     h->long_ref_count++;
  564.                 }
  565.             break;
  566.         case MMCO_LONG2UNUSED:
  567.             j = pic_num_extract(h, mmco[i].long_arg, &structure);
  568.             pic = h->long_ref[j];
  569.             if (pic) {
  570.                 remove_long(h, j, structure ^ PICT_FRAME);
  571.             } else if(s->avctx->debug&FF_DEBUG_MMCO)
  572.                 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: unref long failuren");
  573.             break;
  574.         case MMCO_LONG:
  575.                     // Comment below left from previous code as it is an interresting note.
  576.                     /* First field in pair is in short term list or
  577.                      * at a different long term index.
  578.                      * This is not allowed; see 7.4.3.3, notes 2 and 3.
  579.                      * Report the problem and keep the pair where it is,
  580.                      * and mark this field valid.
  581.                      */
  583.             if (h->long_ref[mmco[i].long_arg] != s->current_picture_ptr) {
  584.                 remove_long(h, mmco[i].long_arg, 0);
  586.                 h->long_ref[ mmco[i].long_arg ]= s->current_picture_ptr;
  587.                 h->long_ref[ mmco[i].long_arg ]->long_ref=1;
  588.                 h->long_ref_count++;
  589.             }
  591.             s->current_picture_ptr->reference |= s->picture_structure;
  592.             current_ref_assigned=1;
  593.             break;
  594.         case MMCO_SET_MAX_LONG:
  595.             assert(mmco[i].long_arg <= 16);
  596.             // just remove the long term which index is greater than new max
  597.             for(j = mmco[i].long_arg; j<16; j++){
  598.                 remove_long(h, j, 0);
  599.             }
  600.             break;
  601.         case MMCO_RESET:
  602.             while(h->short_ref_count){
  603.                 remove_short(h, h->short_ref[0]->frame_num, 0);
  604.             }
  605.             for(j = 0; j < 16; j++) {
  606.                 remove_long(h, j, 0);
  607.             }
  608.             s->current_picture_ptr->poc=
  609.             s->current_picture_ptr->field_poc[0]=
  610.             s->current_picture_ptr->field_poc[1]=
  611.             h->poc_lsb=
  612.             h->poc_msb=
  613.             h->frame_num=
  614.             s->current_picture_ptr->frame_num= 0;
  615.             break;
  616.         default: assert(0);
  617.         }
  618.     }
  620.     if (!current_ref_assigned) {
  621.         /* Second field of complementary field pair; the first field of
  622.          * which is already referenced. If short referenced, it
  623.          * should be first entry in short_ref. If not, it must exist
  624.          * in long_ref; trying to put it on the short list here is an
  625.          * error in the encoded bit stream (ref: 7.4.3.3, NOTE 2 and 3).
  626.          */
  627.         if (h->short_ref_count && h->short_ref[0] == s->current_picture_ptr) {
  628.             /* Just mark the second field valid */
  629.             s->current_picture_ptr->reference = PICT_FRAME;
  630.         } else if (s->current_picture_ptr->long_ref) {
  631.             av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term reference "
  632.                                              "assignment for second field "
  633.                                              "in complementary field pair "
  634.                                              "(first field is long term)n");
  635.         } else {
  636.             pic= remove_short(h, s->current_picture_ptr->frame_num, 0);
  637.             if(pic){
  638.                 av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detectedn");
  639.             }
  641.             if(h->short_ref_count)
  642.                 memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*));
  644.             h->short_ref[0]= s->current_picture_ptr;
  645.             h->short_ref_count++;
  646.             s->current_picture_ptr->reference |= s->picture_structure;
  647.         }
  648.     }
  650.     if (h->long_ref_count + h->short_ref_count > h->sps.ref_frame_count){
  652.         /* We have too many reference frames, probably due to corrupted
  653.          * stream. Need to discard one frame. Prevents overrun of the
  654.          * short_ref and long_ref buffers.
  655.          */
  656.         av_log(h->s.avctx, AV_LOG_ERROR,
  657.                "number of reference frames exceeds max (probably "
  658.                "corrupt input), discarding onen");
  660.         if (h->long_ref_count && !h->short_ref_count) {
  661.             for (i = 0; i < 16; ++i)
  662.                 if (h->long_ref[i])
  663.                     break;
  665.             assert(i < 16);
  666.             remove_long(h, i, 0);
  667.         } else {
  668.             pic = h->short_ref[h->short_ref_count - 1];
  669.             remove_short(h, pic->frame_num, 0);
  670.         }
  671.     }
  673.     print_short_term(h);
  674.     print_long_term(h);
  675.     return 0;
  676. }
  678. static int decode_ref_pic_marking(H264Context *h, GetBitContext *gb){
  679.     MpegEncContext * const s = &h->s;
  680.     int i;
  682.     h->mmco_index= 0;
  683.     if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields
  684.         s->broken_link= get_bits1(gb) -1;
  685.         if(get_bits1(gb)){
  686.             h->mmco[0].opcode= MMCO_LONG;
  687.             h->mmco[0].long_arg= 0;
  688.             h->mmco_index= 1;
  689.         }
  690.     }else{
  691.         if(get_bits1(gb)){ // adaptive_ref_pic_marking_mode_flag
  692.             for(i= 0; i<MAX_MMCO_COUNT; i++) {
  693.                 MMCOOpcode opcode= (MMCOOpcode)get_ue_golomb_31(gb);
  695.                 h->mmco[i].opcode= opcode;
  696.                 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){
  697.                     h->mmco[i].short_pic_num= (h->curr_pic_num - get_ue_golomb(gb) - 1) & (h->max_pic_num - 1);
  698. /*                    if(h->mmco[i].short_pic_num >= h->short_ref_count || h->short_ref[ h->mmco[i].short_pic_num ] == NULL){
  699.                         av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %dn", mmco);
  700.                         return -1;
  701.                     }*/
  702.                 }
  703.                 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){
  704.                     unsigned int long_arg= get_ue_golomb_31(gb);
  705.                     if(long_arg >= 32 || (long_arg >= 16 && !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE))){
  706.                         av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %dn", opcode);
  707.                         return -1;
  708.                     }
  709.                     h->mmco[i].long_arg= long_arg;
  710.                 }
  712.                 if(opcode > (unsigned)MMCO_LONG){
  713.                     av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %dn", opcode);
  714.                     return -1;
  715.                 }
  716.                 if(opcode == MMCO_END)
  717.                     break;
  718.             }
  719.             h->mmco_index= i;
  720.         }else{
  721.             assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count);
  723.             if(h->short_ref_count && h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count &&
  724.                     !(FIELD_PICTURE && !s->first_field && s->current_picture_ptr->reference)) {
  725.                 h->mmco[0].opcode= MMCO_SHORT2UNUSED;
  726.                 h->mmco[0].short_pic_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num;
  727.                 h->mmco_index= 1;
  728.                 if (FIELD_PICTURE) {
  729.                     h->mmco[0].short_pic_num *= 2;
  730.                     h->mmco[1].opcode= MMCO_SHORT2UNUSED;
  731.                     h->mmco[1].short_pic_num= h->mmco[0].short_pic_num + 1;
  732.                     h->mmco_index= 2;
  733.                 }
  734.             }
  735.         }
  736.     }
  738.     return 0;
  739. }
  741. static int init_poc(H264Context *h){
  742.     MpegEncContext * const s = &h->s;
  743.     const int max_frame_num= 1<<h->sps.log2_max_frame_num;
  744.     int field_poc[2];
  745.     Picture *cur = s->current_picture_ptr;
  747.     h->frame_num_offset= h->prev_frame_num_offset;
  748.     if(h->frame_num < h->prev_frame_num)
  749.         h->frame_num_offset += max_frame_num;
  751.     if(h->sps.poc_type==0){
  752.         const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb;
  754.         if     (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2)
  755.             h->poc_msb = h->prev_poc_msb + max_poc_lsb;
  756.         else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2)
  757.             h->poc_msb = h->prev_poc_msb - max_poc_lsb;
  758.         else
  759.             h->poc_msb = h->prev_poc_msb;
  760. //printf("poc: %d %dn", h->poc_msb, h->poc_lsb);
  761.         field_poc[0] =
  762.         field_poc[1] = h->poc_msb + h->poc_lsb;
  763.         if(s->picture_structure == PICT_FRAME)
  764.             field_poc[1] += h->delta_poc_bottom;
  765.     }else if(h->sps.poc_type==1){
  766.         int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
  767.         int i;
  769.         if(h->sps.poc_cycle_length != 0)
  770.             abs_frame_num = h->frame_num_offset + h->frame_num;
  771.         else
  772.             abs_frame_num = 0;
  774.         if(h->nal_ref_idc==0 && abs_frame_num > 0)
  775.             abs_frame_num--;
  777.         expected_delta_per_poc_cycle = 0;
  778.         for(i=0; i < h->sps.poc_cycle_length; i++)
  779.             expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse
  781.         if(abs_frame_num > 0){
  782.             int poc_cycle_cnt          = (abs_frame_num - 1) / h->sps.poc_cycle_length;
  783.             int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length;
  785.             expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
  786.             for(i = 0; i <= frame_num_in_poc_cycle; i++)
  787.                 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ];
  788.         } else
  789.             expectedpoc = 0;
  791.         if(h->nal_ref_idc == 0)
  792.             expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic;
  794.         field_poc[0] = expectedpoc + h->delta_poc[0];
  795.         field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field;
  797.         if(s->picture_structure == PICT_FRAME)
  798.             field_poc[1] += h->delta_poc[1];
  799.     }else{
  800.         int poc= 2*(h->frame_num_offset + h->frame_num);
  802.         if(!h->nal_ref_idc)
  803.             poc--;
  805.         field_poc[0]= poc;
  806.         field_poc[1]= poc;
  807.     }
  809.     if(s->picture_structure != PICT_BOTTOM_FIELD)
  810.         s->current_picture_ptr->field_poc[0]= field_poc[0];
  811.     if(s->picture_structure != PICT_TOP_FIELD)
  812.         s->current_picture_ptr->field_poc[1]= field_poc[1];
  813.     cur->poc= FFMIN(cur->field_poc[0], cur->field_poc[1]);
  815.     return 0;
  816. }
  819. /**
  820.  * initialize scan tables
  821.  */
  822. static void init_scan_tables(H264Context *h){
  823.     MpegEncContext * const s = &h->s;
  824.     int i;
  825.     if(s->dsp.h264_idct_add == ff_h264_idct_add_c){ //FIXME little ugly
  826.         memcpy(h->zigzag_scan, zigzag_scan, 16*sizeof(uint8_t));
  827.         memcpy(h-> field_scan,  field_scan, 16*sizeof(uint8_t));
  828.     }else{
  829.         for(i=0; i<16; i++){
  830. #define T(x) (x>>2) | ((x<<2) & 0xF)
  831.             h->zigzag_scan[i] = T(zigzag_scan[i]);
  832.             h-> field_scan[i] = T( field_scan[i]);
  833. #undef T
  834.         }
  835.     }
  836.     if(s->dsp.h264_idct8_add == ff_h264_idct8_add_c){
  837.         memcpy(h->zigzag_scan8x8,       zigzag_scan8x8,       64*sizeof(uint8_t));
  838.         memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t));
  839.         memcpy(h->field_scan8x8,        field_scan8x8,        64*sizeof(uint8_t));
  840.         memcpy(h->field_scan8x8_cavlc,  field_scan8x8_cavlc,  64*sizeof(uint8_t));
  841.     }else{
  842.         for(i=0; i<64; i++){
  843. #define T(x) (x>>3) | ((x&7)<<3)
  844.             h->zigzag_scan8x8[i]       = T(zigzag_scan8x8[i]);
  845.             h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]);
  846.             h->field_scan8x8[i]        = T(field_scan8x8[i]);
  847.             h->field_scan8x8_cavlc[i]  = T(field_scan8x8_cavlc[i]);
  848. #undef T
  849.         }
  850.     }
  851.     if(h->sps.transform_bypass){ //FIXME same ugly
  852.         h->zigzag_scan_q0          = zigzag_scan;
  853.         h->zigzag_scan8x8_q0       = zigzag_scan8x8;
  854.         h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc;
  855.         h->field_scan_q0           = field_scan;
  856.         h->field_scan8x8_q0        = field_scan8x8;
  857.         h->field_scan8x8_cavlc_q0  = field_scan8x8_cavlc;
  858.     }else{
  859.         h->zigzag_scan_q0          = h->zigzag_scan;
  860.         h->zigzag_scan8x8_q0       = h->zigzag_scan8x8;
  861.         h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc;
  862.         h->field_scan_q0           = h->field_scan;
  863.         h->field_scan8x8_q0        = h->field_scan8x8;
  864.         h->field_scan8x8_cavlc_q0  = h->field_scan8x8_cavlc;
  865.     }
  866. }
  868. /**
  869.  * Replicates H264 "master" context to thread contexts.
  870.  */
  871. static void clone_slice(H264Context *dst, H264Context *src)
  872. {
  873.     memcpy(dst->block_offset,     src->block_offset, sizeof(dst->block_offset));
  874.     dst->s.current_picture_ptr  = src->s.current_picture_ptr;
  875.     dst->s.current_picture      = src->s.current_picture;
  876.     dst->s.linesize             = src->s.linesize;
  877.     dst->s.uvlinesize           = src->s.uvlinesize;
  878.     dst->s.first_field          = src->s.first_field;
  880.     dst->prev_poc_msb           = src->prev_poc_msb;
  881.     dst->prev_poc_lsb           = src->prev_poc_lsb;
  882.     dst->prev_frame_num_offset  = src->prev_frame_num_offset;
  883.     dst->prev_frame_num         = src->prev_frame_num;
  884.     dst->short_ref_count        = src->short_ref_count;
  886.     memcpy(dst->short_ref,        src->short_ref,        sizeof(dst->short_ref));
  887.     memcpy(dst->long_ref,         src->long_ref,         sizeof(dst->long_ref));
  888.     memcpy(dst->default_ref_list, src->default_ref_list, sizeof(dst->default_ref_list));
  889.     memcpy(dst->ref_list,         src->ref_list,         sizeof(dst->ref_list));
  891.     memcpy(dst->dequant4_coeff,   src->dequant4_coeff,   sizeof(src->dequant4_coeff));
  892.     memcpy(dst->dequant8_coeff,   src->dequant8_coeff,   sizeof(src->dequant8_coeff));
  893. }
  895. /**
  896.  * decodes a slice header.
  897.  * This will also call MPV_common_init() and frame_start() as needed.
  898.  *
  899.  * @param h h264context
  900.  * @param h0 h264 master context (differs from 'h' when doing sliced based parallel decoding)
  901.  *
  902.  * @return 0 if okay, <0 if an error occurred, 1 if decoding must not be multithreaded
  903.  */
  904. static int decode_slice_header(H264Context *h, H264Context *h0){
  905.     MpegEncContext * const s = &h->s;
  906.     MpegEncContext * const s0 = &h0->s;
  907.     unsigned int first_mb_in_slice;
  908.     unsigned int pps_id;
  909.     int num_ref_idx_active_override_flag;
  910.     unsigned int slice_type, tmp;
  911. int i, j;
  912.     int default_ref_list_done = 0;
  913.     int last_pic_structure;
  915.     s->dropable= h->nal_ref_idc == 0;
  917.     if((s->avctx->flags2 & CODEC_FLAG2_FAST) && !h->nal_ref_idc){
  918.         s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab;
  919.         s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab;
  920.     }else{
  921.         s->me.qpel_put= s->dsp.put_h264_qpel_pixels_tab;
  922.         s->me.qpel_avg= s->dsp.avg_h264_qpel_pixels_tab;
  923.     }
  925.     first_mb_in_slice= get_ue_golomb(&s->gb);
  927.     if((s->flags2 & CODEC_FLAG2_CHUNKS) && first_mb_in_slice == 0){
  928.         h0->current_slice = 0;
  929.         if (!s0->first_field)
  930.             s->current_picture_ptr= NULL;
  931.     }
  933.     slice_type= get_ue_golomb_31(&s->gb);
  934.     if(slice_type > 9){
  935.         av_log(h->s.avctx, AV_LOG_ERROR, "slice type too large (%d) at %d %dn", h->slice_type, s->mb_x, s->mb_y);
  936.         return -1;
  937.     }
  938.     if(slice_type > 4){
  939.         slice_type -= 5;
  940.         h->slice_type_fixed=1;
  941.     }else
  942.         h->slice_type_fixed=0;
  944.     slice_type= golomb_to_pict_type[ slice_type ];
  945.     if (slice_type == FF_I_TYPE
  946.         || (h0->current_slice != 0 && slice_type == h0->last_slice_type) ) {
  947.         default_ref_list_done = 1;
  948.     }
  949.     h->slice_type= slice_type;
  950.     h->slice_type_nos= slice_type & 3;
  952.     s->pict_type= h->slice_type; // to make a few old functions happy, it's wrong though
  953.     if (s->pict_type == FF_B_TYPE && s0->last_picture_ptr == NULL) {
  954.         av_log(h->s.avctx, AV_LOG_ERROR,
  955.                "B picture before any references, skippingn");
  956.         return -1;
  957.     }
  959.     pps_id= get_ue_golomb(&s->gb);
  960.     if(pps_id>=MAX_PPS_COUNT){
  961.         av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of rangen");
  962.         return -1;
  963.     }
  964.     if(!h0->pps_buffers[pps_id]) {
  965.         av_log(h->s.avctx, AV_LOG_ERROR, "non-existing PPS referencedn");
  966.         return -1;
  967.     }
  968.     h->pps= *h0->pps_buffers[pps_id];
  970.     if(!h0->sps_buffers[h->pps.sps_id]) {
  971.         av_log(h->s.avctx, AV_LOG_ERROR, "non-existing SPS referencedn");
  972.         return -1;
  973.     }
  974.     h->sps = *h0->sps_buffers[h->pps.sps_id];
  976.     if(h == h0 && h->dequant_coeff_pps != pps_id){
  977.         h->dequant_coeff_pps = pps_id;
  978.         init_dequant_tables(h);
  979.     }
  981.     s->mb_width= h->sps.mb_width;
  982.     s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);
  984.     h->b_stride=  s->mb_width*4;
  985.     h->b8_stride= s->mb_width*2;
  987.     s->width = 16*s->mb_width - 2*FFMIN(h->sps.crop_right, 7);
  988.     if(h->sps.frame_mbs_only_flag)
  989.         s->height= 16*s->mb_height - 2*FFMIN(h->sps.crop_bottom, 7);
  990.     else
  991.         s->height= 16*s->mb_height - 4*FFMIN(h->sps.crop_bottom, 3);
  993.     if (s->context_initialized
  994.         && (   s->width != s->avctx->width || s->height != s->avctx->height)) {
  995.         if(h != h0)
  996.             return -1;   // width / height changed during parallelized decoding
  997.         free_tables(h);
  998.         flush_dpb(s->avctx);
  999.         MPV_common_end(s);
  1000.     }
  1001.     if (!s->context_initialized) {
  1002.         if(h != h0)
  1003.             return -1;  // we cant (re-)initialize context during parallel decoding
  1004.         if (MPV_common_init(s) < 0)
  1005.             return -1;
  1006.         s->first_field = 0;
  1008.         init_scan_tables(h);
  1009.         alloc_tables(h);
  1011.         for(i = 1; i < s->avctx->thread_count; i++) {
  1012.             H264Context *c;
  1013.             c = h->thread_context[i] = av_malloc(sizeof(H264Context));
  1014.             memcpy(c, h->s.thread_context[i], sizeof(MpegEncContext));
  1015.             memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext));
  1016.             c->sps = h->sps;
  1017.             c->pps = h->pps;
  1018.             init_scan_tables(c);
  1019.             clone_tables(c, h);
  1020.         }
  1022.         for(i = 0; i < s->avctx->thread_count; i++)
  1023.             if(context_init(h->thread_context[i]) < 0)
  1024.                 return -1;
  1026.         s->avctx->width = s->width;
  1027.         s->avctx->height = s->height;
  1028.         s->avctx->sample_aspect_ratio= h->sps.sar;
  1029.         if(!s->avctx->sample_aspect_ratio.den)
  1030.             s->avctx->sample_aspect_ratio.den = 1;
  1032.         if(h->sps.timing_info_present_flag){
  1033.             //s->avctx->time_base= (AVRational){h->sps.num_units_in_tick * 2, h->sps.time_scale};
  1034. s->avctx->time_base.num = h->sps.num_units_in_tick * 2;
  1035. s->avctx->time_base.den = h->sps.time_scale;
  1036.             if(h->x264_build > 0 && h->x264_build < 44)
  1037.                 s->avctx->time_base.den *= 2;
  1038.             av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,
  1039.                       s->avctx->time_base.num, s->avctx->time_base.den, 1<<30);
  1040.         }
  1041.     }
  1043.     h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num);
  1045.     h->mb_mbaff = 0;
  1046.     h->mb_aff_frame = 0;
  1047.     last_pic_structure = s0->picture_structure;
  1048.     if(h->sps.frame_mbs_only_flag){
  1049.         s->picture_structure= PICT_FRAME;
  1050.     }else{
  1051.         if(get_bits1(&s->gb)) { //field_pic_flag
  1052.             s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag
  1053.         } else {
  1054.             s->picture_structure= PICT_FRAME;
  1055.             h->mb_aff_frame = h->sps.mb_aff;
  1056.         }
  1057.     }
  1058.     h->mb_field_decoding_flag= s->picture_structure != PICT_FRAME;
  1060.     if(h0->current_slice == 0){
  1061.         while(h->frame_num !=  h->prev_frame_num &&
  1062.               h->frame_num != (h->prev_frame_num+1)%(1<<h->sps.log2_max_frame_num)){
  1063.             av_log(NULL, AV_LOG_DEBUG, "Frame num gap %d %dn", h->frame_num, h->prev_frame_num);
  1064.             frame_start(h);
  1065.             h->prev_frame_num++;
  1066.             h->prev_frame_num %= 1<<h->sps.log2_max_frame_num;
  1067.             s->current_picture_ptr->frame_num= h->prev_frame_num;
  1068.             execute_ref_pic_marking(h, NULL, 0);
  1069.         }
  1071.         /* See if we have a decoded first field looking for a pair... */
  1072.         if (s0->first_field) {
  1073.             assert(s0->current_picture_ptr);
  1074.             assert(s0->current_picture_ptr->data[0]);
  1075.             assert(s0->current_picture_ptr->reference != DELAYED_PIC_REF);
  1077.             /* figure out if we have a complementary field pair */
  1078.             if (!FIELD_PICTURE || s->picture_structure == last_pic_structure) {
  1079.                 /*
  1080.                  * Previous field is unmatched. Don't display it, but let it
  1081.                  * remain for reference if marked as such.
  1082.                  */
  1083.                 s0->current_picture_ptr = NULL;
  1084.                 s0->first_field = FIELD_PICTURE;
  1086.             } else {
  1087.                 if (h->nal_ref_idc &&
  1088.                         s0->current_picture_ptr->reference &&
  1089.                         s0->current_picture_ptr->frame_num != h->frame_num) {
  1090.                     /*
  1091.                      * This and previous field were reference, but had
  1092.                      * different frame_nums. Consider this field first in
  1093.                      * pair. Throw away previous field except for reference
  1094.                      * purposes.
  1095.                      */
  1096.                     s0->first_field = 1;
  1097.                     s0->current_picture_ptr = NULL;
  1099.                 } else {
  1100.                     /* Second field in complementary pair */
  1101.                     s0->first_field = 0;
  1102.                 }
  1103.             }
  1105.         } else {
  1106.             /* Frame or first field in a potentially complementary pair */
  1107.             assert(!s0->current_picture_ptr);
  1108.             s0->first_field = FIELD_PICTURE;
  1109.         }
  1111.         if((!FIELD_PICTURE || s0->first_field) && frame_start(h) < 0) {
  1112.             s0->first_field = 0;
  1113.             return -1;
  1114.         }
  1115.     }
  1116.     if(h != h0)
  1117.         clone_slice(h, h0);
  1119.     s->current_picture_ptr->frame_num= h->frame_num; //FIXME frame_num cleanup
  1121.     assert(s->mb_num == s->mb_width * s->mb_height);
  1122.     if((int)first_mb_in_slice << FIELD_OR_MBAFF_PICTURE >= s->mb_num || (int)first_mb_in_slice >= s->mb_num)
  1123. {
  1124.         av_log(h->s.avctx, AV_LOG_ERROR, "first_mb_in_slice overflown");
  1125.         return -1;
  1126.     }
  1127.     s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width;
  1128.     s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << FIELD_OR_MBAFF_PICTURE;
  1129.     if (s->picture_structure == PICT_BOTTOM_FIELD)
  1130.         s->resync_mb_y = s->mb_y = s->mb_y + 1;
  1131.     assert(s->mb_y < s->mb_height);
  1133.     if(s->picture_structure==PICT_FRAME){
  1134.         h->curr_pic_num=   h->frame_num;
  1135.         h->max_pic_num= 1<< h->sps.log2_max_frame_num;
  1136.     }else{
  1137.         h->curr_pic_num= 2*h->frame_num + 1;
  1138.         h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1);
  1139.     }
  1141.     if(h->nal_unit_type == NAL_IDR_SLICE){
  1142.         get_ue_golomb(&s->gb); /* idr_pic_id */
  1143.     }
  1145.     if(h->sps.poc_type==0){
  1146.         h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb);
  1148.         if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){
  1149.             h->delta_poc_bottom= get_se_golomb(&s->gb);
  1150.         }
  1151.     }
  1153.     if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){
  1154.         h->delta_poc[0]= get_se_golomb(&s->gb);
  1156.         if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME)
  1157.             h->delta_poc[1]= get_se_golomb(&s->gb);
  1158.     }
  1160.     init_poc(h);
  1162.     if(h->pps.redundant_pic_cnt_present){
  1163.         h->redundant_pic_count= get_ue_golomb(&s->gb);
  1164.     }
  1166.     //set defaults, might be overridden a few lines later
  1167.     h->ref_count[0]= h->pps.ref_count[0];
  1168.     h->ref_count[1]= h->pps.ref_count[1];
  1170.     if(h->slice_type_nos != FF_I_TYPE){
  1171.         if(h->slice_type_nos == FF_B_TYPE){
  1172.             h->direct_spatial_mv_pred= get_bits1(&s->gb);
  1173.         }
  1174.         num_ref_idx_active_override_flag= get_bits1(&s->gb);
  1176.         if(num_ref_idx_active_override_flag){
  1177.             h->ref_count[0]= get_ue_golomb(&s->gb) + 1;
  1178.             if(h->slice_type_nos==FF_B_TYPE)
  1179.                 h->ref_count[1]= get_ue_golomb(&s->gb) + 1;
  1181.             if(h->ref_count[0]-1 > 32-1 || h->ref_count[1]-1 > 32-1){
  1182.                 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflown");
  1183.                 h->ref_count[0]= h->ref_count[1]= 1;
  1184.                 return -1;
  1185.             }
  1186.         }
  1187.         if(h->slice_type_nos == FF_B_TYPE)
  1188.             h->list_count= 2;
  1189.         else
  1190.             h->list_count= 1;
  1191.     }else
  1192.         h->list_count= 0;
  1194.     if(!default_ref_list_done){
  1195.         fill_default_ref_list(h);
  1196.     }
  1198.     if(h->slice_type_nos!=FF_I_TYPE && decode_ref_pic_list_reordering(h) < 0)
  1199.         return -1;
  1201.     if(h->slice_type_nos!=FF_I_TYPE){
  1202.         s->last_picture_ptr= &h->ref_list[0][0];
  1203.         ff_copy_picture(&s->last_picture, s->last_picture_ptr);
  1204.     }
  1205.     if(h->slice_type_nos==FF_B_TYPE){
  1206.         s->next_picture_ptr= &h->ref_list[1][0];
  1207.         ff_copy_picture(&s->next_picture, s->next_picture_ptr);
  1208.     }
  1210.     if(   (h->pps.weighted_pred          && h->slice_type_nos == FF_P_TYPE )
  1211.        ||  (h->pps.weighted_bipred_idc==1 && h->slice_type_nos== FF_B_TYPE ) )
  1212.         pred_weight_table(h);
  1213.     else if(h->pps.weighted_bipred_idc==2 && h->slice_type_nos== FF_B_TYPE)
  1214.         implicit_weight_table(h);
  1215.     else
  1216.         h->use_weight = 0;
  1218.     if(h->nal_ref_idc)
  1219.         decode_ref_pic_marking(h0, &s->gb);
  1221.     if(FRAME_MBAFF)
  1222.         fill_mbaff_ref_list(h);
  1224.     if(h->slice_type_nos==FF_B_TYPE && !h->direct_spatial_mv_pred)
  1225.         direct_dist_scale_factor(h);
  1226.     direct_ref_list_init(h);
  1228.     if( h->slice_type_nos != FF_I_TYPE && h->pps.cabac ){
  1229.         tmp = get_ue_golomb_31(&s->gb);
  1230.         if(tmp > 2){
  1231.             av_log(s->avctx, AV_LOG_ERROR, "cabac_init_idc overflown");
  1232.             return -1;
  1233.         }
  1234.         h->cabac_init_idc= tmp;
  1235.     }
  1237.     h->last_qscale_diff = 0;
  1238.     tmp = h->pps.init_qp + get_se_golomb(&s->gb);
  1239.     if(tmp>51){
  1240.         av_log(s->avctx, AV_LOG_ERROR, "QP %u out of rangen", tmp);
  1241.         return -1;
  1242.     }
  1243.     s->qscale= tmp;
  1244.     h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
  1245.     h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
  1246.     //FIXME qscale / qp ... stuff
  1247.     if(h->slice_type == FF_SP_TYPE){
  1248.         get_bits1(&s->gb); /* sp_for_switch_flag */
  1249.     }
  1250.     if(h->slice_type==FF_SP_TYPE || h->slice_type == FF_SI_TYPE){
  1251.         get_se_golomb(&s->gb); /* slice_qs_delta */
  1252.     }
  1254.     h->deblocking_filter = 1;
  1255.     h->slice_alpha_c0_offset = 0;
  1256.     h->slice_beta_offset = 0;
  1257.     if( h->pps.deblocking_filter_parameters_present ) {
  1258.         tmp= get_ue_golomb_31(&s->gb);
  1259.         if(tmp > 2){
  1260.             av_log(s->avctx, AV_LOG_ERROR, "deblocking_filter_idc %u out of rangen", tmp);
  1261.             return -1;
  1262.         }
  1263.         h->deblocking_filter= tmp;
  1264.         if(h->deblocking_filter < 2)
  1265.             h->deblocking_filter^= 1; // 1<->0
  1267.         if( h->deblocking_filter ) {
  1268.             h->slice_alpha_c0_offset = get_se_golomb(&s->gb) << 1;
  1269.             h->slice_beta_offset = get_se_golomb(&s->gb) << 1;
  1270.         }
  1271.     }
  1273.     if(   s->avctx->skip_loop_filter >= AVDISCARD_ALL
  1274.        ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type_nos != FF_I_TYPE)
  1275.        ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR  && h->slice_type_nos == FF_B_TYPE)
  1276.        ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
  1277.         h->deblocking_filter= 0;
  1279.     if(h->deblocking_filter == 1 && h0->max_contexts > 1) {
  1280.         if(s->avctx->flags2 & CODEC_FLAG2_FAST) {
  1281.             /* Cheat slightly for speed:
  1282.                Do not bother to deblock across slices. */
  1283.             h->deblocking_filter = 2;
  1284.         } else {
  1285.             h0->max_contexts = 1;
  1286.             if(!h0->single_decode_warning) {
  1287.                 av_log(s->avctx, AV_LOG_INFO, "Cannot parallelize deblocking type 1, decoding such frames in sequential ordern");
  1288.                 h0->single_decode_warning = 1;
  1289.             }
  1290.             if(h != h0)
  1291.                 return 1; // deblocking switched inside frame
  1292.         }
  1293.     }
  1295. #if 0 //FMO
  1296.     if( h->pps.num_slice_groups > 1  && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5)
  1297.         slice_group_change_cycle= get_bits(&s->gb, ?);
  1298. #endif
  1300.     h0->last_slice_type = slice_type;
  1301.     h->slice_num = ++h0->current_slice;
  1302.     if(h->slice_num >= MAX_SLICES){
  1303.         av_log(s->avctx, AV_LOG_ERROR, "Too many slices, increase MAX_SLICES and recompilen");
  1304.     }
  1306.     for(j=0; j<2; j++){
  1307.         int *ref2frm= h->ref2frm[h->slice_num&(MAX_SLICES-1)][j];
  1308.         ref2frm[0]=
  1309.         ref2frm[1]= -1;
  1310.         for(i=0; i<16; i++)
  1311.             ref2frm[i+2]= 4*h->ref_list[j][i].frame_num
  1312.                           +(h->ref_list[j][i].reference&3);
  1313.         ref2frm[18+0]=
  1314.         ref2frm[18+1]= -1;
  1315.         for(i=16; i<48; i++)
  1316.             ref2frm[i+4]= 4*h->ref_list[j][i].frame_num
  1317.                           +(h->ref_list[j][i].reference&3);
  1318.     }
  1320.     h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16;
  1321.     h->emu_edge_height= (FRAME_MBAFF || FIELD_PICTURE) ? 0 : h->emu_edge_width;
  1323.     s->avctx->refs= h->sps.ref_frame_count;
  1325.     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
  1326.         av_log(h->s.avctx, AV_LOG_DEBUG, "slice:%d %s mb:%d %c%s%s pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %sn",
  1327.                h->slice_num,
  1328.                (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"),
  1329.                first_mb_in_slice,
  1330.                av_get_pict_type_char(h->slice_type), h->slice_type_fixed ? " fix" : "", h->nal_unit_type == NAL_IDR_SLICE ? " IDR" : "",
  1331.                pps_id, h->frame_num,
  1332.                s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1],
  1333.                h->ref_count[0], h->ref_count[1],
  1334.                s->qscale,
  1335.                h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2,
  1336.                h->use_weight,
  1337.                h->use_weight==1 && h->use_weight_chroma ? "c" : "",
  1338.                h->slice_type == FF_B_TYPE ? (h->direct_spatial_mv_pred ? "SPAT" : "TEMP") : ""
  1339.                );
  1340.     }
  1342.     return 0;
  1343. }
  1345. /**
  1346.  *
  1347.  */
  1348. static inline int get_level_prefix(GetBitContext *gb){
  1349.     unsigned int buf;
  1350.     int log;
  1352.     OPEN_READER(re, gb);
  1353.     UPDATE_CACHE(re, gb);
  1354.     buf=GET_CACHE(re, gb);
  1356.     log= 32 - av_log2(buf);
  1357. #ifdef TRACE
  1358.     print_bin(buf>>(32-log), log);
  1359.     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d lpr @%5d in %s get_level_prefixn", buf>>(32-log), log, log-1, get_bits_count(gb), __FILE__);
  1360. #endif
  1362.     LAST_SKIP_BITS(re, gb, log);
  1363.     CLOSE_READER(re, gb);
  1365.     return log-1;
  1366. }
  1368. static inline int get_dct8x8_allowed(H264Context *h){
  1369.     if(h->sps.direct_8x8_inference_flag)
  1370.         return !(*(uint64_t*)h->sub_mb_type & ((MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_8x8                )*0x0001000100010001ULL));
  1371.     else
  1372.         return !(*(uint64_t*)h->sub_mb_type & ((MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_8x8|MB_TYPE_DIRECT2)*0x0001000100010001ULL));
  1373. }
  1375. /**
  1376.  * decodes a residual block.
  1377.  * @param n block index
  1378.  * @param scantable scantable
  1379.  * @param max_coeff number of coefficients in the block
  1380.  * @return <0 if an error occurred
  1381.  */
  1382. static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
  1383.     MpegEncContext * const s = &h->s;
  1384.     static const int coeff_token_table_index[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3};
  1385.     int level[16];
  1386.     int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before;
  1388.     //FIXME put trailing_onex into the context
  1390.     if(n == CHROMA_DC_BLOCK_INDEX){
  1391.         coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
  1392.         total_coeff= coeff_token>>2;
  1393.     }else{
  1394.         if(n == LUMA_DC_BLOCK_INDEX){
  1395.             total_coeff= pred_non_zero_count(h, 0);
  1396.             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
  1397.             total_coeff= coeff_token>>2;
  1398.         }else{
  1399.             total_coeff= pred_non_zero_count(h, n);
  1400.             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
  1401.             total_coeff= coeff_token>>2;
  1402.             h->non_zero_count_cache[ scan8[n] ]= total_coeff;
  1403.         }
  1404.     }
  1406.     //FIXME set last_non_zero?
  1408.     if(total_coeff==0)
  1409.         return 0;
  1410.     if(total_coeff > max_coeff) 
  1411. {
  1412.         av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)n", s->mb_x, s->mb_y, total_coeff);
  1413.         return -1;
  1414.     }
  1416.     trailing_ones= coeff_token&3;
  1417.     tprintf(h->s.avctx, "trailing:%d, total:%dn", trailing_ones, total_coeff);
  1418.     assert(total_coeff<=16);
  1420.     i = show_bits(gb, 3);
  1421.     skip_bits(gb, trailing_ones);
  1422.     level[0] = 1-((i&4)>>1);
  1423.     level[1] = 1-((i&2)   );
  1424.     level[2] = 1-((i&1)<<1);
  1426.     if(trailing_ones<total_coeff) {
  1427.         int mask, prefix;
  1428.         int suffix_length = total_coeff > 10 && trailing_ones < 3;
  1429.         int bitsi= show_bits(gb, LEVEL_TAB_BITS);
  1430.         int level_code= cavlc_level_tab[suffix_length][bitsi][0];
  1432.         skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
  1433.         if(level_code >= 100){
  1434.             prefix= level_code - 100;
  1435.             if(prefix == LEVEL_TAB_BITS)
  1436.                 prefix += get_level_prefix(gb);
  1438.             //first coefficient has suffix_length equal to 0 or 1
  1439.             if(prefix<14){ //FIXME try to build a large unified VLC table for all this
  1440.                 if(suffix_length)
  1441.                     level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
  1442.                 else
  1443.                     level_code= (prefix<<suffix_length); //part
  1444.             }else if(prefix==14){
  1445.                 if(suffix_length)
  1446.                     level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
  1447.                 else
  1448.                     level_code= prefix + get_bits(gb, 4); //part
  1449.             }else{
  1450.                 level_code= (15<<suffix_length) + get_bits(gb, prefix-3); //part
  1451.                 if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense
  1452.                 if(prefix>=16)
  1453.                     level_code += (1<<(prefix-3))-4096;
  1454.             }
  1456.             if(trailing_ones < 3) level_code += 2;
  1458.             suffix_length = 2;
  1459.             mask= -(level_code&1);
  1460.             level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
  1461.         }else{
  1462.             if(trailing_ones < 3) level_code += (level_code>>31)|1;
  1464.             suffix_length = 1;
  1465.             if(level_code + 3U > 6U)
  1466.                 suffix_length++;
  1467.             level[trailing_ones]= level_code;
  1468.         }
  1470.         //remaining coefficients have suffix_length > 0
  1471.         for(i=trailing_ones+1;i<total_coeff;i++) {
  1472.             static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
  1473.             int bitsi= show_bits(gb, LEVEL_TAB_BITS);
  1474.             level_code= cavlc_level_tab[suffix_length][bitsi][0];
  1476.             skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
  1477.             if(level_code >= 100){
  1478.                 prefix= level_code - 100;
  1479.                 if(prefix == LEVEL_TAB_BITS){
  1480.                     prefix += get_level_prefix(gb);
  1481.                 }
  1482.                 if(prefix<15){
  1483.                     level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
  1484.                 }else{
  1485.                     level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
  1486.                     if(prefix>=16)
  1487.                         level_code += (1<<(prefix-3))-4096;
  1488.                 }
  1489.                 mask= -(level_code&1);
  1490.                 level_code= (((2+level_code)>>1) ^ mask) - mask;
  1491.             }
  1492.             level[i]= level_code;
  1494.             if(suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length])
  1495.                 suffix_length++;
  1496.         }
  1497.     }
  1499.     if(total_coeff == max_coeff)
  1500.         zeros_left=0;
  1501.     else{
  1502.         if(n == CHROMA_DC_BLOCK_INDEX)
  1503.             zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
  1504.         else
  1505.             zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1);
  1506.     }
  1508.     coeff_num = zeros_left + total_coeff - 1;
  1509.     j = scantable[coeff_num];
  1510.     if(n > 24){
  1511.         block[j] = level[0];
  1512.         for(i=1;i<total_coeff;i++) {
  1513.             if(zeros_left <= 0)
  1514.                 run_before = 0;
  1515.             else if(zeros_left < 7){
  1516.                 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);
  1517.             }else{
  1518.                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
  1519.             }
  1520.             zeros_left -= run_before;
  1521.             coeff_num -= 1 + run_before;
  1522.             j= scantable[ coeff_num ];
  1524.             block[j]= level[i];
  1525.         }
  1526.     }else{
  1527.         block[j] = (level[0] * qmul[j] + 32)>>6;
  1528.         for(i=1;i<total_coeff;i++) {
  1529.             if(zeros_left <= 0)
  1530.                 run_before = 0;
  1531.             else if(zeros_left < 7){
  1532.                 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);
  1533.             }else{
  1534.                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
  1535.             }
  1536.             zeros_left -= run_before;
  1537.             coeff_num -= 1 + run_before;
  1538.             j= scantable[ coeff_num ];
  1540.             block[j]= (level[i] * qmul[j] + 32)>>6;
  1541.         }
  1542.     }
  1544.     if(zeros_left<0){
  1545.         av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %dn", s->mb_x, s->mb_y);
  1546.         return -1;
  1547.     }
  1549.     return 0;
  1550. }
  1552. static void predict_field_decoding_flag(H264Context *h){
  1553.     MpegEncContext * const s = &h->s;
  1554.     const int mb_xy= h->mb_xy;
  1555.     int mb_type = (h->slice_table[mb_xy-1] == h->slice_num)
  1556.                 ? s->current_picture.mb_type[mb_xy-1]
  1557.                 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num)
  1558.                 ? s->current_picture.mb_type[mb_xy-s->mb_stride]
  1559.                 : 0;
  1560.     h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
  1561. }
  1563. /**
  1564.  * decodes a P_SKIP or B_SKIP macroblock
  1565.  */
  1566. static void decode_mb_skip(H264Context *h){
  1567.     MpegEncContext * const s = &h->s;
  1568.     const int mb_xy= h->mb_xy;
  1569.     int mb_type=0;
  1571.     memset(h->non_zero_count[mb_xy], 0, 16);
  1572.     memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui
  1574.     if(MB_FIELD)
  1575.         mb_type|= MB_TYPE_INTERLACED;
  1577.     if( h->slice_type_nos == FF_B_TYPE )
  1578.     {
  1579.         // just for fill_caches. pred_direct_motion will set the real mb_type
  1580.         mb_type|= MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP;
  1582.         fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ...
  1583.         pred_direct_motion(h, &mb_type);
  1584.         mb_type|= MB_TYPE_SKIP;
  1585.     }
  1586.     else
  1587.     {
  1588.         int mx, my;
  1589.         mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP;
  1591.         fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ...
  1592.         pred_pskip_motion(h, &mx, &my);
  1593.         fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);
  1594.         fill_rectangle(  h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4);
  1595.     }
  1597.     write_back_motion(h, mb_type);
  1598.     s->current_picture.mb_type[mb_xy]= mb_type;
  1599.     s->current_picture.qscale_table[mb_xy]= s->qscale;
  1600.     h->slice_table[ mb_xy ]= h->slice_num;
  1601.     h->prev_mb_skipped= 1;
  1602. }
  1604. /**
  1605.  * decodes a macroblock
  1606.  * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
  1607.  */
  1608. static int decode_mb_cavlc(H264Context *h){
  1609.     MpegEncContext * const s = &h->s;
  1610.     int mb_xy;
  1611.     int partition_count;
  1612.     unsigned int mb_type, cbp;
  1613.     int dct8x8_allowed= h->pps.transform_8x8_mode;
  1615.     mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
  1617.     tprintf(s->avctx, "pic:%d mb:%d/%dn", h->frame_num, s->mb_x, s->mb_y);
  1618.     cbp = 0; /* avoid warning. FIXME: find a solution without slowing
  1619.                 down the code */
  1620.     if(h->slice_type_nos != FF_I_TYPE){
  1621.         if(s->mb_skip_run==-1)
  1622.             s->mb_skip_run= get_ue_golomb(&s->gb);
  1624.         if (s->mb_skip_run--) {
  1625.             if(FRAME_MBAFF && (s->mb_y&1) == 0){
  1626.                 if(s->mb_skip_run==0)
  1627.                     h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
  1628.                 else
  1629.                     predict_field_decoding_flag(h);
  1630.             }
  1631.             decode_mb_skip(h);
  1632.             return 0;
  1633.         }
  1634.     }
  1635.     if(FRAME_MBAFF){
  1636.         if( (s->mb_y&1) == 0 )
  1637.             h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
  1638.     }
  1640.     h->prev_mb_skipped= 0;
  1642.     mb_type= get_ue_golomb(&s->gb);
  1643.     if(h->slice_type_nos == FF_B_TYPE){
  1644.         if(mb_type < 23){
  1645.             partition_count= b_mb_type_info[mb_type].partition_count;
  1646.             mb_type=         b_mb_type_info[mb_type].type;
  1647.         }else{
  1648.             mb_type -= 23;
  1649.             goto decode_intra_mb;
  1650.         }
  1651.     }else if(h->slice_type_nos == FF_P_TYPE){
  1652.         if(mb_type < 5){
  1653.             partition_count= p_mb_type_info[mb_type].partition_count;
  1654.             mb_type=         p_mb_type_info[mb_type].type;
  1655.         }else{
  1656.             mb_type -= 5;
  1657.             goto decode_intra_mb;
  1658.         }
  1659.     }else{
  1660.        assert(h->slice_type_nos == FF_I_TYPE);
  1661.         if(h->slice_type == FF_SI_TYPE && mb_type)
  1662.             mb_type--;
  1663. decode_intra_mb:
  1664.         if(mb_type > 25){
  1665.             av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %dn", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);
  1666.             return -1;
  1667.         }
  1668.         partition_count=0;
  1669.         cbp= i_mb_type_info[mb_type].cbp;
  1670.         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
  1671.         mb_type= i_mb_type_info[mb_type].type;
  1672.     }
  1674.     if(MB_FIELD)
  1675.         mb_type |= MB_TYPE_INTERLACED;
  1677.     h->slice_table[ mb_xy ]= h->slice_num;
  1679.     if(IS_INTRA_PCM(mb_type)){
  1680.         int x;
  1682.         // We assume these blocks are very rare so we do not optimize it.
  1683.         align_get_bits(&s->gb);
  1685.         // The pixels are stored in the same order as levels in h->mb array.
  1686.         for(x=0; x < (CHROMA ? 384 : 256); x++){
  1687.             ((uint8_t*)h->mb)[x]= get_bits(&s->gb, 8);
  1688.         }
  1690.         // In deblocking, the quantizer is 0
  1691.         s->current_picture.qscale_table[mb_xy]= 0;
  1692.         // All coeffs are present
  1693.         memset(h->non_zero_count[mb_xy], 16, 16);
  1695.         s->current_picture.mb_type[mb_xy]= mb_type;
  1696.         return 0;
  1697.     }
  1699.     if(MB_MBAFF){
  1700.         h->ref_count[0] <<= 1;
  1701.         h->ref_count[1] <<= 1;
  1702.     }
  1704.     fill_caches(h, mb_type, 0);
  1706.     //mb_pred
  1707.     if(IS_INTRA(mb_type)){
  1708.         int pred_mode;
  1709. //            init_top_left_availability(h);
  1710.         if(IS_INTRA4x4(mb_type)){
  1711.             int i;
  1712.             int di = 1;
  1713.             if(dct8x8_allowed && get_bits1(&s->gb)){
  1714.                 mb_type |= MB_TYPE_8x8DCT;
  1715.                 di = 4;
  1716.             }
  1718. //                fill_intra4x4_pred_table(h);
  1719.             for(i=0; i<16; i+=di){
  1720.                 int mode= pred_intra_mode(h, i);
  1722.                 if(!get_bits1(&s->gb)){
  1723.                     const int rem_mode= get_bits(&s->gb, 3);
  1724.                     mode = rem_mode + (rem_mode >= mode);
  1725.                 }
  1727.                 if(di==4)
  1728.                     fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
  1729.                 else
  1730.                     h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
  1731.             }
  1732.             write_back_intra_pred_mode(h);
  1733.             if( check_intra4x4_pred_mode(h) < 0)
  1734.                 return -1;
  1735.         }else{
  1736.             h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode);
  1737.             if(h->intra16x16_pred_mode < 0)
  1738.                 return -1;
  1739.         }
  1740.         if(CHROMA){
  1741.             pred_mode= check_intra_pred_mode(h, get_ue_golomb_31(&s->gb));
  1742.             if(pred_mode < 0)
  1743.                 return -1;
  1744.             h->chroma_pred_mode= pred_mode;
  1745.         }
  1746.     }else if(partition_count==4){
  1747.         int i, j, sub_partition_count[4], list, ref[2][4];
  1749.         if(h->slice_type_nos == FF_B_TYPE){
  1750.             for(i=0; i<4; i++){
  1751.                 h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
  1752.                 if(h->sub_mb_type[i] >=13){
  1753.                     av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %dn", h->sub_mb_type[i], s->mb_x, s->mb_y);
  1754.                     return -1;
  1755.                 }
  1756.                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
  1757.                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
  1758.             }
  1759.             if(   IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1])
  1760.                || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {
  1761.                 pred_direct_motion(h, &mb_type);
  1762.                 h->ref_cache[0][scan8[4]] =
  1763.                 h->ref_cache[1][scan8[4]] =
  1764.                 h->ref_cache[0][scan8[12]] =
  1765.                 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
  1766.             }
  1767.         }else{
  1768.             assert(h->slice_type_nos == FF_P_TYPE); //FIXME SP correct ?
  1769.             for(i=0; i<4; i++){
  1770.                 h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
  1771.                 if(h->sub_mb_type[i] >=4){
  1772.                     av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %dn", h->sub_mb_type[i], s->mb_x, s->mb_y);
  1773.                     return -1;
  1774.                 }
  1775.                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
  1776.                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
  1777.             }
  1778.         }
  1780.         for(list=0; list<h->list_count; list++){
  1781.             int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
  1782.             for(i=0; i<4; i++){
  1783.                 if(IS_DIRECT(h->sub_mb_type[i])) continue;
  1784.                 if(IS_DIR(h->sub_mb_type[i], 0, list)){
  1785.                     unsigned int tmp;
  1786.                     if(ref_count == 1){
  1787.                         tmp= 0;
  1788.                     }else if(ref_count == 2){
  1789.                         tmp= get_bits1(&s->gb)^1;
  1790.                     }else{
  1791.                         tmp= get_ue_golomb_31(&s->gb);
  1792.                         if((int)tmp>=ref_count){
  1793.                             av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflown", tmp);
  1794.                             return -1;
  1795.                         }
  1796.                     }
  1797.                     ref[list][i]= tmp;
  1798.                 }else{
  1799.                  //FIXME
  1800.                     ref[list][i] = -1;
  1801.                 }
  1802.             }
  1803.         }
  1805.         if(dct8x8_allowed)
  1806.             dct8x8_allowed = get_dct8x8_allowed(h);
  1808.         for(list=0; list<h->list_count; list++){
  1809.             for(i=0; i<4; i++){
  1810.                 if(IS_DIRECT(h->sub_mb_type[i])) {
  1811.                     h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
  1812.                     continue;
  1813.                 }
  1814.                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ]=
  1815.                 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
  1817.                 if(IS_DIR(h->sub_mb_type[i], 0, list)){
  1818.                     const int sub_mb_type= h->sub_mb_type[i];
  1819.                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
  1820.                     for(j=0; j<sub_partition_count[i]; j++){
  1821.                         int mx, my;
  1822.                         const int index= 4*i + block_width*j;
  1823.                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
  1824.                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
  1825.                         mx += get_se_golomb(&s->gb);
  1826.                         my += get_se_golomb(&s->gb);
  1827.                         tprintf(s->avctx, "final mv:%d %dn", mx, my);
  1829.                         if(IS_SUB_8X8(sub_mb_type)){
  1830.                             mv_cache[ 1 ][0]=
  1831.                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
  1832.                             mv_cache[ 1 ][1]=
  1833.                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
  1834.                         }else if(IS_SUB_8X4(sub_mb_type)){
  1835.                             mv_cache[ 1 ][0]= mx;
  1836.                             mv_cache[ 1 ][1]= my;
  1837.                         }else if(IS_SUB_4X8(sub_mb_type)){
  1838.                             mv_cache[ 8 ][0]= mx;
  1839.                             mv_cache[ 8 ][1]= my;
  1840.                         }
  1841.                         mv_cache[ 0 ][0]= mx;
  1842.                         mv_cache[ 0 ][1]= my;
  1843.                     }
  1844.                 }else{
  1845.                     uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
  1846.                     p[0] = p[1]=
  1847.                     p[8] = p[9]= 0;
  1848.                 }
  1849.             }
  1850.         }
  1851.     }else if(IS_DIRECT(mb_type)){
  1852.         pred_direct_motion(h, &mb_type);
  1853.         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
  1854.     }else{
  1855.         int list, mx, my, i;
  1856.          //FIXME we should set ref_idx_l? to 0 if we use that later ...
  1857.         if(IS_16X16(mb_type)){
  1858.             for(list=0; list<h->list_count; list++){
  1859.                     unsigned int val;
  1860.                     if(IS_DIR(mb_type, 0, list)){
  1861.                         if(h->ref_count[list]==1){
  1862.                             val= 0;
  1863.                         }else if(h->ref_count[list]==2){
  1864.                             val= get_bits1(&s->gb)^1;
  1865.                         }else{
  1866.                             val= get_ue_golomb_31(&s->gb);
  1867.                             if((int)val >= h->ref_count[list]){
  1868.                                 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflown", val);
  1869.                                 return -1;
  1870.                             }
  1871.                         }
  1872.                     }else
  1873.                         val= LIST_NOT_USED&0xFF;
  1874.                     fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
  1875.             }
  1876.             for(list=0; list<h->list_count; list++){
  1877.                 unsigned int val;
  1878.                 if(IS_DIR(mb_type, 0, list)){
  1879.                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
  1880.                     mx += get_se_golomb(&s->gb);
  1881.                     my += get_se_golomb(&s->gb);
  1882.                     tprintf(s->avctx, "final mv:%d %dn", mx, my);
  1884.                     val= pack16to32(mx,my);
  1885.                 }else
  1886.                     val=0;
  1887.                 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, val, 4);
  1888.             }
  1889.         }
  1890.         else if(IS_16X8(mb_type)){
  1891.             for(list=0; list<h->list_count; list++){
  1892.                     for(i=0; i<2; i++){
  1893.                         unsigned int val;
  1894.                         if(IS_DIR(mb_type, i, list)){
  1895.                             if(h->ref_count[list] == 1){
  1896.                                 val= 0;
  1897.                             }else if(h->ref_count[list] == 2){
  1898.                                 val= get_bits1(&s->gb)^1;
  1899.                             }else{
  1900.                                 val= get_ue_golomb_31(&s->gb);
  1901.                                 if((int)val >= h->ref_count[list]){
  1902.                                     av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflown", val);
  1903.                                     return -1;
  1904.                                 }
  1905.                             }
  1906.                         }else
  1907.                             val= LIST_NOT_USED&0xFF;
  1908.                         fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
  1909.                     }
  1910.             }
  1911.             for(list=0; list<h->list_count; list++){
  1912.                 for(i=0; i<2; i++){
  1913.                     unsigned int val;
  1914.                     if(IS_DIR(mb_type, i, list)){
  1915.                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
  1916.                         mx += get_se_golomb(&s->gb);
  1917.                         my += get_se_golomb(&s->gb);
  1918.                         tprintf(s->avctx, "final mv:%d %dn", mx, my);
  1920.                         val= pack16to32(mx,my);
  1921.                     }else
  1922.                         val=0;
  1923.                     fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
  1924.                 }
  1925.             }
  1926.         }else{
  1927.             assert(IS_8X16(mb_type));
  1928.             for(list=0; list<h->list_count; list++){
  1929.                     for(i=0; i<2; i++){
  1930.                         unsigned int val;
  1931.                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
  1932.                             if(h->ref_count[list]==1){
  1933.                                 val= 0;
  1934.                             }else if(h->ref_count[list]==2){
  1935.                                 val= get_bits1(&s->gb)^1;
  1936.                             }else{
  1937.                                 val= get_ue_golomb_31(&s->gb);
  1938.                                 if((int)val >= h->ref_count[list])
  1939. {
  1940.                                     av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflown", val);
  1941.                                     return -1;
  1942.                                 }
  1943.                             }
  1944.                         }else
  1945.                             val= LIST_NOT_USED&0xFF;
  1946.                         fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
  1947.                     }
  1948.             }
  1949.             for(list=0; list<h->list_count; list++){
  1950.                 for(i=0; i<2; i++){
  1951.                     unsigned int val;
  1952.                     if(IS_DIR(mb_type, i, list)){
  1953.                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
  1954.                         mx += get_se_golomb(&s->gb);
  1955.                         my += get_se_golomb(&s->gb);
  1956.                         tprintf(s->avctx, "final mv:%d %dn", mx, my);
  1958.                         val= pack16to32(mx,my);
  1959.                     }else
  1960.                         val=0;
  1961.                     fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
  1962.                 }
  1963.             }
  1964.         }
  1965.     }
  1967.     if(IS_INTER(mb_type))
  1968.         write_back_motion(h, mb_type);
  1970.     if(!IS_INTRA16x16(mb_type)){
  1971.         cbp= get_ue_golomb(&s->gb);
  1972.         if(cbp > 47){
  1973.             av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %dn", cbp, s->mb_x, s->mb_y);
  1974.             return -1;
  1975.         }
  1977.         if(CHROMA){
  1978.             if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
  1979.             else                     cbp= golomb_to_inter_cbp   [cbp];
  1980.         }else{
  1981.             if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
  1982.             else                     cbp= golomb_to_inter_cbp_gray[cbp];
  1983.         }
  1984.     }
  1985.     h->cbp = cbp;
  1987.     if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
  1988.         if(get_bits1(&s->gb)){
  1989.             mb_type |= MB_TYPE_8x8DCT;
  1990.             h->cbp_table[mb_xy]= cbp;
  1991.         }
  1992.     }
  1993.     s->current_picture.mb_type[mb_xy]= mb_type;
  1995.     if(cbp || IS_INTRA16x16(mb_type)){
  1996.         int i8x8, i4x4, chroma_idx;
  1997.         int dquant;
  1998.         GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
  1999.         const uint8_t *scan, *scan8x8, *dc_scan;
  2001. //        fill_non_zero_count_cache(h);
  2003.         if(IS_INTERLACED(mb_type)){
  2004.             scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
  2005.             scan= s->qscale ? h->field_scan : h->field_scan_q0;
  2006.             dc_scan= luma_dc_field_scan;
  2007.         }else{
  2008.             scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
  2009.             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
  2010.             dc_scan= luma_dc_zigzag_scan;
  2011.         }
  2013.         dquant= get_se_golomb(&s->gb);
  2015.         if( dquant > 25 || dquant < -26 ){
  2016.             av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %dn", dquant, s->mb_x, s->mb_y);
  2017.             return -1;
  2018.         }
  2020.         s->qscale += dquant;
  2021.         if(((unsigned)s->qscale) > 51){
  2022.             if(s->qscale<0) s->qscale+= 52;
  2023.             else            s->qscale-= 52;
  2024.         }
  2026.         h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale);
  2027.         h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale);
  2028.         if(IS_INTRA16x16(mb_type)){
  2029.             if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){
  2030.                 return -1; //FIXME continue if partitioned and other return -1 too
  2031.             }
  2033.             assert((cbp&15) == 0 || (cbp&15) == 15);
  2035.             if(cbp&15){
  2036.                 for(i8x8=0; i8x8<4; i8x8++){
  2037.                     for(i4x4=0; i4x4<4; i4x4++){
  2038.                         const int index= i4x4 + 4*i8x8;
  2039.                         if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){
  2040.                             return -1;
  2041.                         }
  2042.                     }
  2043.                 }
  2044.             }else{
  2045.                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
  2046.             }
  2047.         }else{
  2048.             for(i8x8=0; i8x8<4; i8x8++){
  2049.                 if(cbp & (1<<i8x8)){
  2050.                     if(IS_8x8DCT(mb_type)){
  2051.                         DCTELEM *buf = &h->mb[64*i8x8];
  2052.                         uint8_t *nnz;
  2053.                         for(i4x4=0; i4x4<4; i4x4++){
  2054.                             if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4,
  2055.                                                 h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 )
  2056.                                 return -1;
  2057.                         }
  2058.                         nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
  2059.                         nnz[0] += nnz[1] + nnz[8] + nnz[9];
  2060.                     }else{
  2061.                         for(i4x4=0; i4x4<4; i4x4++){
  2062.                             const int index= i4x4 + 4*i8x8;
  2064.                             if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){
  2065.                                 return -1;
  2066.                             }
  2067.                         }
  2068.                     }
  2069.                 }else{
  2070.                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
  2071.                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
  2072.                 }
  2073.             }
  2074.         }
  2076.         if(cbp&0x30){
  2077.             for(chroma_idx=0; chroma_idx<2; chroma_idx++)
  2078.                 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){
  2079.                     return -1;
  2080.                 }
  2081.         }
  2083.         if(cbp&0x20){
  2084.             for(chroma_idx=0; chroma_idx<2; chroma_idx++){
  2085.                 const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
  2086.                 for(i4x4=0; i4x4<4; i4x4++){
  2087.                     const int index= 16 + 4*chroma_idx + i4x4;
  2088.                     if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, qmul, 15) < 0){
  2089.                         return -1;
  2090.                     }
  2091.                 }
  2092.             }
  2093.         }else{
  2094.             uint8_t * const nnz= &h->non_zero_count_cache[0];
  2095.             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
  2096.             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
  2097.         }
  2098.     }else{
  2099.         uint8_t * const nnz= &h->non_zero_count_cache[0];
  2100.         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
  2101.         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
  2102.         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
  2103.     }
  2104.     s->current_picture.qscale_table[mb_xy]= s->qscale;
  2105.     write_back_non_zero_count(h);
  2107.     if(MB_MBAFF){
  2108.         h->ref_count[0] >>= 1;
  2109.         h->ref_count[1] >>= 1;
  2110.     }
  2112.     return 0;
  2113. }
  2115. static int decode_cabac_field_decoding_flag(H264Context *h) {
  2116.     MpegEncContext * const s = &h->s;
  2117.     const int mb_x = s->mb_x;
  2118.     const int mb_y = s->mb_y & ~1;
  2119.     const int mba_xy = mb_x - 1 +  mb_y   *s->mb_stride;
  2120.     const int mbb_xy = mb_x     + (mb_y-2)*s->mb_stride;
  2122.     unsigned int ctx = 0;
  2124.     if( h->slice_table[mba_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) {
  2125.         ctx += 1;
  2126.     }
  2127.     if( h->slice_table[mbb_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) {
  2128.         ctx += 1;
  2129.     }
  2131.     return get_cabac_noinline( &h->cabac, &h->cabac_state[70 + ctx] );
  2132. }
  2134. static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
  2135.     uint8_t *state= &h->cabac_state[ctx_base];
  2136.     int mb_type;
  2138.     if(intra_slice){
  2139.         MpegEncContext * const s = &h->s;
  2140.         const int mba_xy = h->left_mb_xy[0];
  2141.         const int mbb_xy = h->top_mb_xy;
  2142.         int ctx=0;
  2143.         if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) )
  2144.             ctx++;
  2145.         if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) )
  2146.             ctx++;
  2147.         if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
  2148.             return 0;   /* I4x4 */
  2149.         state += 2;
  2150.     }else{
  2151.         if( get_cabac_noinline( &h->cabac, &state[0] ) == 0 )
  2152.             return 0;   /* I4x4 */
  2153.     }
  2155.     if( get_cabac_terminate( &h->cabac ) )
  2156.         return 25;  /* PCM */
  2158.     mb_type = 1; /* I16x16 */
  2159.     mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */
  2160.     if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */
  2161.         mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] );
  2162.     mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] );
  2163.     mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] );
  2164.     return mb_type;
  2165. }
  2167. static int decode_cabac_mb_type_b( H264Context *h ) {
  2168.     MpegEncContext * const s = &h->s;
  2170.         const int mba_xy = h->left_mb_xy[0];
  2171.         const int mbb_xy = h->top_mb_xy;
  2172.         int ctx = 0;
  2173.         int bits;
  2174.         assert(h->slice_type_nos == FF_B_TYPE);
  2176.         if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )
  2177.             ctx++;
  2178.         if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) )
  2179.             ctx++;
  2181.         if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) )
  2182.             return 0; /* B_Direct_16x16 */
  2184.         if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
  2185.             return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
  2186.         }
  2188.         bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
  2189.         bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
  2190.         bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
  2191.         bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
  2192.         if( bits < 8 )
  2193.             return bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
  2194.         else if( bits == 13 ) {
  2195.             return decode_cabac_intra_mb_type(h, 32, 0) + 23;
  2196.         } else if( bits == 14 )
  2197.             return 11; /* B_L1_L0_8x16 */
  2198.         else if( bits == 15 )
  2199.             return 22; /* B_8x8 */
  2201.         bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
  2202.         return bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
  2203. }
  2205. static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
  2206.     MpegEncContext * const s = &h->s;
  2207.     int mba_xy, mbb_xy;
  2208.     int ctx = 0;
  2210.     if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
  2211.         int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
  2212.         mba_xy = mb_xy - 1;
  2213.         if( (mb_y&1)
  2214.             && h->slice_table[mba_xy] == h->slice_num
  2215.             && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
  2216.             mba_xy += s->mb_stride;
  2217.         if( MB_FIELD ){
  2218.             mbb_xy = mb_xy - s->mb_stride;
  2219.             if( !(mb_y&1)
  2220.                 && h->slice_table[mbb_xy] == h->slice_num
  2221.                 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
  2222.                 mbb_xy -= s->mb_stride;
  2223.         }else
  2224.             mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
  2225.     }else{
  2226.         int mb_xy = h->mb_xy;
  2227.         mba_xy = mb_xy - 1;
  2228.         mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
  2229.     }
  2231.     if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
  2232.         ctx++;
  2233.     if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
  2234.         ctx++;
  2236.     if( h->slice_type_nos == FF_B_TYPE )
  2237.         ctx += 13;
  2238.     return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
  2239. }
  2241. static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
  2242.     int mode = 0;
  2244.     if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
  2245.         return pred_mode;
  2247.     mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
  2248.     mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
  2249.     mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
  2251.     if( mode >= pred_mode )
  2252.         return mode + 1;
  2253.     else
  2254.         return mode;
  2255. }
  2257. static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
  2258.     const int mba_xy = h->left_mb_xy[0];
  2259.     const int mbb_xy = h->top_mb_xy;
  2261.     int ctx = 0;
  2263.     /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
  2264.     if( h->slice_table[mba_xy] == h->slice_num && h->chroma_pred_mode_table[mba_xy] != 0 )
  2265.         ctx++;
  2267.     if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )
  2268.         ctx++;
  2270.     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
  2271.         return 0;
  2273.     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
  2274.         return 1;
  2275.     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
  2276.         return 2;
  2277.     else
  2278.         return 3;
  2279. }
  2281. static int decode_cabac_mb_cbp_luma( H264Context *h) {
  2282.     int cbp_b, cbp_a, ctx, cbp = 0;
  2284.     cbp_a = h->slice_table[h->left_mb_xy[0]] == h->slice_num ? h->left_cbp : -1;
  2285.     cbp_b = h->slice_table[h->top_mb_xy]     == h->slice_num ? h->top_cbp  : -1;
  2287.     ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);
  2288.     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);
  2289.     ctx = !(cbp   & 0x01) + 2 * !(cbp_b & 0x08);
  2290.     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;
  2291.     ctx = !(cbp_a & 0x08) + 2 * !(cbp   & 0x01);
  2292.     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;
  2293.     ctx = !(cbp   & 0x04) + 2 * !(cbp   & 0x02);
  2294.     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;
  2295.     return cbp;
  2296. }
  2297. static int decode_cabac_mb_cbp_chroma( H264Context *h) {
  2298.     int ctx;
  2299.     int cbp_a, cbp_b;
  2301.     cbp_a = (h->left_cbp>>4)&0x03;
  2302.     cbp_b = (h-> top_cbp>>4)&0x03;
  2304.     ctx = 0;
  2305.     if( cbp_a > 0 ) ctx++;
  2306.     if( cbp_b > 0 ) ctx += 2;
  2307.     if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
  2308.         return 0;
  2310.     ctx = 4;
  2311.     if( cbp_a == 2 ) ctx++;
  2312.     if( cbp_b == 2 ) ctx += 2;
  2313.     return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
  2314. }
  2315. static int decode_cabac_mb_dqp( H264Context *h) {
  2316.     int   ctx= h->last_qscale_diff != 0;
  2317.     int   val = 0;
  2319.     while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
  2320.         ctx= 2+(ctx>>1);
  2321.         val++;
  2322.         if(val > 102) //prevent infinite loop
  2323.             return INT_MIN;
  2324.     }
  2326.     if( val&0x01 )
  2327.         return   (val + 1)>>1 ;
  2328.     else
  2329.         return -((val + 1)>>1);
  2330. }
  2331. static int decode_cabac_p_mb_sub_type( H264Context *h ) {
  2332.     if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
  2333.         return 0;   /* 8x8 */
  2334.     if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
  2335.         return 1;   /* 8x4 */
  2336.     if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
  2337.         return 2;   /* 4x8 */
  2338.     return 3;       /* 4x4 */
  2339. }
  2340. static int decode_cabac_b_mb_sub_type( H264Context *h ) {
  2341.     int type;
  2342.     if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
  2343.         return 0;   /* B_Direct_8x8 */
  2344.     if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
  2345.         return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
  2346.     type = 3;
  2347.     if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
  2348.         if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
  2349.             return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
  2350.         type += 4;
  2351.     }
  2352.     type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
  2353.     type +=   get_cabac( &h->cabac, &h->cabac_state[39] );
  2354.     return type;
  2355. }
  2357. static inline int decode_cabac_mb_transform_size( H264Context *h ) {
  2358.     return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
  2359. }
  2361. static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
  2362.     int refa = h->ref_cache[list][scan8[n] - 1];
  2363.     int refb = h->ref_cache[list][scan8[n] - 8];
  2364.     int ref  = 0;
  2365.     int ctx  = 0;
  2367.     if( h->slice_type_nos == FF_B_TYPE) {
  2368.         if( refa > 0 && !h->direct_cache[scan8[n] - 1] )
  2369.             ctx++;
  2370.         if( refb > 0 && !h->direct_cache[scan8[n] - 8] )
  2371.             ctx += 2;
  2372.     } else {
  2373.         if( refa > 0 )
  2374.             ctx++;
  2375.         if( refb > 0 )
  2376.             ctx += 2;
  2377.     }
  2379.     while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
  2380.         ref++;
  2381.         ctx = (ctx>>2)+4;
  2382.         if(ref >= 32 /*h->ref_list[list]*/){
  2383.             return -1;
  2384.         }
  2385.     }
  2386.     return ref;
  2387. }
  2389. static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
  2390.     int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
  2391.                abs( h->mvd_cache[list][scan8[n] - 8][l] );
  2392.     int ctxbase = (l == 0) ? 40 : 47;
  2393.     int mvd;
  2394.     int ctx = (amvd>2) + (amvd>32);
  2396.     if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
  2397.         return 0;
  2399.     mvd= 1;
  2400.     ctx= 3;
  2401.     while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
  2402.         mvd++;
  2403.         if( ctx < 6 )
  2404.             ctx++;
  2405.     }
  2407.     if( mvd >= 9 ) {
  2408.         int k = 3;
  2409.         while( get_cabac_bypass( &h->cabac ) ) {
  2410.             mvd += 1 << k;
  2411.             k++;
  2412.             if(k>24){
  2413.                 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvdn");
  2414.                 return INT_MIN;
  2415.             }
  2416.         }
  2417.         while( k-- ) {
  2418.             if( get_cabac_bypass( &h->cabac ) )
  2419.                 mvd += 1 << k;
  2420.         }
  2421.     }
  2422.     return get_cabac_bypass_sign( &h->cabac, -mvd );
  2423. }
  2425. static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
  2426.     int nza, nzb;
  2427.     int ctx = 0;
  2429.     if( is_dc ) {
  2430.         if( cat == 0 ) {
  2431.             nza = h->left_cbp&0x100;
  2432.             nzb = h-> top_cbp&0x100;
  2433.         } else {
  2434.             nza = (h->left_cbp>>(6+idx))&0x01;
  2435.             nzb = (h-> top_cbp>>(6+idx))&0x01;
  2436.         }
  2437.     } else {
  2438.         assert(cat == 1 || cat == 2 || cat == 4);
  2439.         nza = h->non_zero_count_cache[scan8[idx] - 1];
  2440.         nzb = h->non_zero_count_cache[scan8[idx] - 8];
  2441.     }
  2443.     if( nza > 0 )
  2444.         ctx++;
  2446.     if( nzb > 0 )
  2447.         ctx += 2;
  2449.     return ctx + 4 * cat;
  2450. }
  2452. DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8[63]) = {
  2453.     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  2454.     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  2455.     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
  2456.     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
  2457. };
  2459. 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 ) {
  2460.     static const int significant_coeff_flag_offset[2][6] = {
  2461.       { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
  2462.       { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
  2463.     };
  2464.     static const int last_coeff_flag_offset[2][6] = {
  2465.       { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
  2466.       { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
  2467.     };
  2468.     static const int coeff_abs_level_m1_offset[6] = {
  2469.         227+0, 227+10, 227+20, 227+30, 227+39, 426
  2470.     };
  2471.     static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
  2472.       { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
  2473.         4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
  2474.         7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
  2475.        12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
  2476.       { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
  2477.         6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
  2478.         9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
  2479.         9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
  2480.     };
  2481.     /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
  2482.      * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
  2483.      * map node ctx => cabac ctx for level=1 */
  2484.     static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
  2485.     /* map node ctx => cabac ctx for level>1 */
  2486.     static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
  2487.     static const uint8_t coeff_abs_level_transition[2][8] = {
  2488.     /* update node ctx after decoding a level=1 */
  2489.         { 1, 2, 3, 3, 4, 5, 6, 7 },
  2490.     /* update node ctx after decoding a level>1 */
  2491.         { 4, 4, 4, 4, 5, 6, 7, 7 }
  2492.     };
  2494.     int index[64];
  2496.     int av_unused last;
  2497.     int coeff_count = 0;
  2498.     int node_ctx = 0;
  2500.     uint8_t *significant_coeff_ctx_base;
  2501.     uint8_t *last_coeff_ctx_base;
  2502.     uint8_t *abs_level_m1_ctx_base;
  2504. #ifndef ARCH_X86
  2505. #define CABAC_ON_STACK
  2506. #endif
  2507. #ifdef CABAC_ON_STACK
  2508. #define CC &cc
  2509.     CABACContext cc;
  2510.     cc.range     = h->cabac.range;
  2511.     cc.low       = h->cabac.low;
  2512.     cc.bytestream= h->cabac.bytestream;
  2513. #else
  2514. #define CC &h->cabac
  2515. #endif
  2518.     /* cat: 0-> DC 16x16  n = 0
  2519.      *      1-> AC 16x16  n = luma4x4idx
  2520.      *      2-> Luma4x4   n = luma4x4idx
  2521.      *      3-> DC Chroma n = iCbCr
  2522.      *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
  2523.      *      5-> Luma8x8   n = 4 * luma8x8idx
  2524.      */
  2526.     /* read coded block flag */
  2527.     if( is_dc || cat != 5 ) {
  2528.         if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
  2529.             if( !is_dc )
  2530.                 h->non_zero_count_cache[scan8[n]] = 0;
  2532. #ifdef CABAC_ON_STACK
  2533.             h->cabac.range     = cc.range     ;
  2534.             h->cabac.low       = cc.low       ;
  2535.             h->cabac.bytestream= cc.bytestream;
  2536. #endif
  2537.             return;
  2538.         }
  2539.     }
  2541.     significant_coeff_ctx_base = h->cabac_state
  2542.         + significant_coeff_flag_offset[MB_FIELD][cat];
  2543.     last_coeff_ctx_base = h->cabac_state
  2544.         + last_coeff_flag_offset[MB_FIELD][cat];
  2545.     abs_level_m1_ctx_base = h->cabac_state
  2546.         + coeff_abs_level_m1_offset[cat];
  2548.     if( !is_dc && cat == 5 ) {
  2549. #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) 
  2550.         for(last= 0; last < coefs; last++) { 
  2551.             uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; 
  2552.             if( get_cabac( CC, sig_ctx )) { 
  2553.                 uint8_t *last_ctx = last_coeff_ctx_base + last_off; 
  2554.                 index[coeff_count++] = last; 
  2555.                 if( get_cabac( CC, last_ctx ) ) { 
  2556.                     last= max_coeff; 
  2557.                     break; 
  2558.                 } 
  2559.             } 
  2560.         }
  2561.         if( last == max_coeff -1 ) {
  2562.             index[coeff_count++] = last;
  2563.         }
  2564.         const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
  2565. #if defined(ARCH_X86) && defined(HAVE_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS)
  2566.         coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
  2567.     } else {
  2568.         coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
  2569. #else
  2570.         DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
  2571.     } else {
  2572.         DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
  2573. #endif
  2574.     }
  2575.     assert(coeff_count > 0);
  2577.     if( is_dc ) {
  2578.         if( cat == 0 )
  2579.             h->cbp_table[h->mb_xy] |= 0x100;
  2580.         else
  2581.             h->cbp_table[h->mb_xy] |= 0x40 << n;
  2582.     } else {
  2583.         if( cat == 5 )
  2584.             fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
  2585.         else {
  2586.             assert( cat == 1 || cat == 2 || cat == 4 );
  2587.             h->non_zero_count_cache[scan8[n]] = coeff_count;
  2588.         }
  2589.     }
  2591.     do {
  2592.         uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
  2594.         int j= scantable[index[--coeff_count]];
  2596.         if( get_cabac( CC, ctx ) == 0 ) 
  2597. {
  2598.             int32_t ret;
  2599. node_ctx = coeff_abs_level_transition[0][node_ctx];
  2600.             if( is_dc ) 
  2601. {
  2602.                 block[j] = get_cabac_bypass_sign( CC, -1);
  2603.             }
  2604. else
  2605. {
  2606.                 //block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
  2607. ret = qmul[j];
  2608. block[j] = (get_cabac_bypass_sign( CC, -ret) + 32) >> 6;
  2609.             }
  2610.         } 
  2611. else 
  2612. {
  2613.             int coeff_abs = 2;
  2614.             ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
  2615.             node_ctx = coeff_abs_level_transition[1][node_ctx];
  2617.             while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
  2618.                 coeff_abs++;
  2619.             }
  2621.             if( coeff_abs >= 15 ) {
  2622.                 int j = 0;
  2623.                 while( get_cabac_bypass( CC ) ) {
  2624.                     j++;
  2625.                 }
  2627.                 coeff_abs=1;
  2628.                 while( j-- ) {
  2629.                     coeff_abs += coeff_abs + get_cabac_bypass( CC );
  2630.                 }
  2631.                 coeff_abs+= 14;
  2632.             }
  2634.             if( is_dc ) {
  2635.                 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
  2636.             }else{
  2637.                 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
  2638.             }
  2639.         }
  2640.     } while( coeff_count );
  2641. #ifdef CABAC_ON_STACK
  2642.             h->cabac.range     = cc.range     ;
  2643.             h->cabac.low       = cc.low       ;
  2644.             h->cabac.bytestream= cc.bytestream;
  2645. #endif
  2647. }
  2649. #ifndef CONFIG_SMALL
  2650. 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 ) {
  2651.     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
  2652. }
  2654. 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 ) {
  2655.     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
  2656. }
  2657. #endif
  2659. static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
  2660. #ifdef CONFIG_SMALL
  2661.     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
  2662. #else
  2663.     if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
  2664.     else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
  2665. #endif
  2666. }
  2668. static inline void compute_mb_neighbors(H264Context *h)
  2669. {
  2670.     MpegEncContext * const s = &h->s;
  2671.     const int mb_xy  = h->mb_xy;
  2672.     h->top_mb_xy     = mb_xy - s->mb_stride;
  2673.     h->left_mb_xy[0] = mb_xy - 1;
  2674.     if(FRAME_MBAFF){
  2675.         const int pair_xy          = s->mb_x     + (s->mb_y & ~1)*s->mb_stride;
  2676.         const int top_pair_xy      = pair_xy     - s->mb_stride;
  2677.         const int top_mb_field_flag  = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
  2678.         const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
  2679.         const int curr_mb_field_flag = MB_FIELD;
  2680.         const int bottom = (s->mb_y & 1);
  2682.         if (curr_mb_field_flag && (bottom || top_mb_field_flag)){
  2683.             h->top_mb_xy -= s->mb_stride;
  2684.         }
  2685.         if (!left_mb_field_flag == curr_mb_field_flag) {
  2686.             h->left_mb_xy[0] = pair_xy - 1;
  2687.         }
  2688.     } else if (FIELD_PICTURE) {
  2689.         h->top_mb_xy -= s->mb_stride;
  2690.     }
  2691.     return;
  2692. }
  2694. /**
  2695.  * decodes a macroblock
  2696.  * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
  2697.  */
  2698. static int decode_mb_cabac(H264Context *h) {
  2699.     MpegEncContext * const s = &h->s;
  2700.     int mb_xy;
  2701.     int mb_type, partition_count, cbp = 0;
  2702.     int dct8x8_allowed= h->pps.transform_8x8_mode;
  2704.     mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
  2706.     tprintf(s->avctx, "pic:%d mb:%d/%dn", h->frame_num, s->mb_x, s->mb_y);
  2707.     if( h->slice_type_nos != FF_I_TYPE ) {
  2708.         int skip;
  2709.         /* a skipped mb needs the aff flag from the following mb */
  2710.         if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 )
  2711.             predict_field_decoding_flag(h);
  2712.         if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
  2713.             skip = h->next_mb_skipped;
  2714.         else
  2715.             skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
  2716.         /* read skip flags */
  2717.         if( skip ) {
  2718.             if( FRAME_MBAFF && (s->mb_y&1)==0 ){
  2719.                 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
  2720.                 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
  2721.                 if(!h->next_mb_skipped)
  2722.                     h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
  2723.             }
  2725.             decode_mb_skip(h);
  2727.             h->cbp_table[mb_xy] = 0;
  2728.             h->chroma_pred_mode_table[mb_xy] = 0;
  2729.             h->last_qscale_diff = 0;
  2731.             return 0;
  2733.         }
  2734.     }
  2735.     if(FRAME_MBAFF){
  2736.         if( (s->mb_y&1) == 0 )
  2737.             h->mb_mbaff =
  2738.             h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
  2739.     }
  2741.     h->prev_mb_skipped = 0;
  2743.     compute_mb_neighbors(h);
  2745.     if( h->slice_type_nos == FF_B_TYPE ) {
  2746.         mb_type = decode_cabac_mb_type_b( h );
  2747.         if( mb_type < 23 ){
  2748.             partition_count= b_mb_type_info[mb_type].partition_count;
  2749.             mb_type=         b_mb_type_info[mb_type].type;
  2750.         }else{
  2751.             mb_type -= 23;
  2752.             goto decode_intra_mb;
  2753.         }
  2754.     } else if( h->slice_type_nos == FF_P_TYPE ) {
  2755.         if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
  2756.             /* P-type */
  2757.             if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
  2758.                 /* P_L0_D16x16, P_8x8 */
  2759.                 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
  2760.             } else {
  2761.                 /* P_L0_D8x16, P_L0_D16x8 */
  2762.                 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
  2763.             }
  2764.             partition_count= p_mb_type_info[mb_type].partition_count;
  2765.             mb_type=         p_mb_type_info[mb_type].type;
  2766.         } else {
  2767.             mb_type= decode_cabac_intra_mb_type(h, 17, 0);
  2768.             goto decode_intra_mb;
  2769.         }
  2770.     } else {
  2771.         mb_type= decode_cabac_intra_mb_type(h, 3, 1);
  2772.         if(h->slice_type == FF_SI_TYPE && mb_type)
  2773.             mb_type--;
  2774.         assert(h->slice_type_nos == FF_I_TYPE);