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

8656 lines
323KB
Raw Blame History 

  1. /*

  2.  * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder

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

  4.  *

  5.  * This file is part of FFmpeg.

  6.  *

  7.  * FFmpeg is free software; you can redistribute it and/or

  8.  * modify it under the terms of the GNU Lesser General Public

  9.  * License as published by the Free Software Foundation; either

  10.  * version 2.1 of the License, or (at your option) any later version.

  11.  *

  12.  * FFmpeg is distributed in the hope that it will be useful,

  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  15.  * Lesser General Public License for more details.

  16.  *

  17.  * You should have received a copy of the GNU Lesser General Public

  18.  * License along with FFmpeg; if not, write to the Free Software

  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  20.  *

  21.  */

  22. 

  23. /**

  24.  * @file h264.c

  25.  * H.264 / AVC / MPEG4 part10 codec.

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

  27.  */

  28. 

  29. #include "common.h"

  30. #include "dsputil.h"

  31. #include "avcodec.h"

  32. #include "mpegvideo.h"

  33. #include "h264data.h"

  34. #include "golomb.h"

  35. 

  36. #include "cabac.h"

  37. 

  38. //#undef NDEBUG

  39. #include <assert.h>

  40. 

  41. #define interlaced_dct interlaced_dct_is_a_bad_name

  42. #define mb_intra mb_intra_isnt_initalized_see_mb_type

  43. 

  44. #define LUMA_DC_BLOCK_INDEX   25

  45. #define CHROMA_DC_BLOCK_INDEX 26

  46. 

  47. #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8

  48. #define COEFF_TOKEN_VLC_BITS           8

  49. #define TOTAL_ZEROS_VLC_BITS           9

  50. #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3

  51. #define RUN_VLC_BITS                   3

  52. #define RUN7_VLC_BITS                  6

  53. 

  54. #define MAX_SPS_COUNT 32

  55. #define MAX_PPS_COUNT 256

  56. 

  57. #define MAX_MMCO_COUNT 66

  58. 

  59. /* Compiling in interlaced support reduces the speed

  60.  * of progressive decoding by about 2%. */

  61. #define ALLOW_INTERLACE

  62. 

  63. #ifdef ALLOW_INTERLACE

  64. #define MB_MBAFF h->mb_mbaff

  65. #define MB_FIELD h->mb_field_decoding_flag

  66. #define FRAME_MBAFF h->mb_aff_frame

  67. #else

  68. #define MB_MBAFF 0

  69. #define MB_FIELD 0

  70. #define FRAME_MBAFF 0

  71. #undef  IS_INTERLACED

  72. #define IS_INTERLACED(mb_type) 0

  73. #endif

  74. 

  75. /**

  76.  * Sequence parameter set

  77.  */

  78. typedef struct SPS{

  79. 

  80.     int profile_idc;

  81.     int level_idc;

  82.     int transform_bypass;              ///< qpprime_y_zero_transform_bypass_flag

  83.     int log2_max_frame_num;            ///< log2_max_frame_num_minus4 + 4

  84.     int poc_type;                      ///< pic_order_cnt_type

  85.     int log2_max_poc_lsb;              ///< log2_max_pic_order_cnt_lsb_minus4

  86.     int delta_pic_order_always_zero_flag;

  87.     int offset_for_non_ref_pic;

  88.     int offset_for_top_to_bottom_field;

  89.     int poc_cycle_length;              ///< num_ref_frames_in_pic_order_cnt_cycle

  90.     int ref_frame_count;               ///< num_ref_frames

  91.     int gaps_in_frame_num_allowed_flag;

  92.     int mb_width;                      ///< frame_width_in_mbs_minus1 + 1

  93.     int mb_height;                     ///< frame_height_in_mbs_minus1 + 1

  94.     int frame_mbs_only_flag;

  95.     int mb_aff;                        ///<mb_adaptive_frame_field_flag

  96.     int direct_8x8_inference_flag;

  97.     int crop;                   ///< frame_cropping_flag

  98.     int crop_left;              ///< frame_cropping_rect_left_offset

  99.     int crop_right;             ///< frame_cropping_rect_right_offset

  100.     int crop_top;               ///< frame_cropping_rect_top_offset

  101.     int crop_bottom;            ///< frame_cropping_rect_bottom_offset

  102.     int vui_parameters_present_flag;

  103.     AVRational sar;

  104.     int timing_info_present_flag;

  105.     uint32_t num_units_in_tick;

  106.     uint32_t time_scale;

  107.     int fixed_frame_rate_flag;

  108.     short offset_for_ref_frame[256]; //FIXME dyn aloc?

  109.     int bitstream_restriction_flag;

  110.     int num_reorder_frames;

  111.     int scaling_matrix_present;

  112.     uint8_t scaling_matrix4[6][16];

  113.     uint8_t scaling_matrix8[2][64];

  114. }SPS;

  115. 

  116. /**

  117.  * Picture parameter set

  118.  */

  119. typedef struct PPS{

  120.     int sps_id;

  121.     int cabac;                  ///< entropy_coding_mode_flag

  122.     int pic_order_present;      ///< pic_order_present_flag

  123.     int slice_group_count;      ///< num_slice_groups_minus1 + 1

  124.     int mb_slice_group_map_type;

  125.     int ref_count[2];           ///< num_ref_idx_l0/1_active_minus1 + 1

  126.     int weighted_pred;          ///< weighted_pred_flag

  127.     int weighted_bipred_idc;

  128.     int init_qp;                ///< pic_init_qp_minus26 + 26

  129.     int init_qs;                ///< pic_init_qs_minus26 + 26

  130.     int chroma_qp_index_offset;

  131.     int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag

  132.     int constrained_intra_pred; ///< constrained_intra_pred_flag

  133.     int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag

  134.     int transform_8x8_mode;     ///< transform_8x8_mode_flag

  135.     uint8_t scaling_matrix4[6][16];

  136.     uint8_t scaling_matrix8[2][64];

  137. }PPS;

  138. 

  139. /**

  140.  * Memory management control operation opcode.

  141.  */

  142. typedef enum MMCOOpcode{

  143.     MMCO_END=0,

  144.     MMCO_SHORT2UNUSED,

  145.     MMCO_LONG2UNUSED,

  146.     MMCO_SHORT2LONG,

  147.     MMCO_SET_MAX_LONG,

  148.     MMCO_RESET,

  149.     MMCO_LONG,

  150. } MMCOOpcode;

  151. 

  152. /**

  153.  * Memory management control operation.

  154.  */

  155. typedef struct MMCO{

  156.     MMCOOpcode opcode;

  157.     int short_frame_num;

  158.     int long_index;

  159. } MMCO;

  160. 

  161. /**

  162.  * H264Context

  163.  */

  164. typedef struct H264Context{

  165.     MpegEncContext s;

  166.     int nal_ref_idc;

  167.     int nal_unit_type;

  168. #define NAL_SLICE                1

  169. #define NAL_DPA                  2

  170. #define NAL_DPB                  3

  171. #define NAL_DPC                  4

  172. #define NAL_IDR_SLICE            5

  173. #define NAL_SEI                  6

  174. #define NAL_SPS                  7

  175. #define NAL_PPS                  8

  176. #define NAL_AUD                  9

  177. #define NAL_END_SEQUENCE        10

  178. #define NAL_END_STREAM          11

  179. #define NAL_FILLER_DATA         12

  180. #define NAL_SPS_EXT             13

  181. #define NAL_AUXILIARY_SLICE     19

  182.     uint8_t *rbsp_buffer;

  183.     unsigned int rbsp_buffer_size;

  184. 

  185.     /**

  186.       * Used to parse AVC variant of h264

  187.       */

  188.     int is_avc; ///< this flag is != 0 if codec is avc1

  189.     int got_avcC; ///< flag used to parse avcC data only once

  190.     int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4)

  191. 

  192.     int chroma_qp; //QPc

  193. 

  194.     int prev_mb_skipped;

  195.     int next_mb_skipped;

  196. 

  197.     //prediction stuff

  198.     int chroma_pred_mode;

  199.     int intra16x16_pred_mode;

  200. 

  201.     int top_mb_xy;

  202.     int left_mb_xy[2];

  203. 

  204.     int8_t intra4x4_pred_mode_cache[5*8];

  205.     int8_t (*intra4x4_pred_mode)[8];

  206.     void (*pred4x4  [9+3])(uint8_t *src, uint8_t *topright, int stride);//FIXME move to dsp?

  207.     void (*pred8x8l [9+3])(uint8_t *src, int topleft, int topright, int stride);

  208.     void (*pred8x8  [4+3])(uint8_t *src, int stride);

  209.     void (*pred16x16[4+3])(uint8_t *src, int stride);

  210.     unsigned int topleft_samples_available;

  211.     unsigned int top_samples_available;

  212.     unsigned int topright_samples_available;

  213.     unsigned int left_samples_available;

  214.     uint8_t (*top_borders[2])[16+2*8];

  215.     uint8_t left_border[2*(17+2*9)];

  216. 

  217.     /**

  218.      * non zero coeff count cache.

  219.      * is 64 if not available.

  220.      */

  221.     DECLARE_ALIGNED_8(uint8_t, non_zero_count_cache[6*8]);

  222.     uint8_t (*non_zero_count)[16];

  223. 

  224.     /**

  225.      * Motion vector cache.

  226.      */

  227.     DECLARE_ALIGNED_8(int16_t, mv_cache[2][5*8][2]);

  228.     DECLARE_ALIGNED_8(int8_t, ref_cache[2][5*8]);

  229. #define LIST_NOT_USED -1 //FIXME rename?

  230. #define PART_NOT_AVAILABLE -2

  231. 

  232.     /**

  233.      * is 1 if the specific list MV&references are set to 0,0,-2.

  234.      */

  235.     int mv_cache_clean[2];

  236. 

  237.     /**

  238.      * number of neighbors (top and/or left) that used 8x8 dct

  239.      */

  240.     int neighbor_transform_size;

  241. 

  242.     /**

  243.      * block_offset[ 0..23] for frame macroblocks

  244.      * block_offset[24..47] for field macroblocks

  245.      */

  246.     int block_offset[2*(16+8)];

  247. 

  248.     uint32_t *mb2b_xy; //FIXME are these 4 a good idea?

  249.     uint32_t *mb2b8_xy;

  250.     int b_stride; //FIXME use s->b4_stride

  251.     int b8_stride;

  252. 

  253.     int mb_linesize;   ///< may be equal to s->linesize or s->linesize*2, for mbaff

  254.     int mb_uvlinesize;

  255. 

  256.     int emu_edge_width;

  257.     int emu_edge_height;

  258. 

  259.     int halfpel_flag;

  260.     int thirdpel_flag;

  261. 

  262.     int unknown_svq3_flag;

  263.     int next_slice_index;

  264. 

  265.     SPS sps_buffer[MAX_SPS_COUNT];

  266.     SPS sps; ///< current sps

  267. 

  268.     PPS pps_buffer[MAX_PPS_COUNT];

  269.     /**

  270.      * current pps

  271.      */

  272.     PPS pps; //FIXME move to Picture perhaps? (->no) do we need that?

  273. 

  274.     uint32_t dequant4_buffer[6][52][16];

  275.     uint32_t dequant8_buffer[2][52][64];

  276.     uint32_t (*dequant4_coeff[6])[16];

  277.     uint32_t (*dequant8_coeff[2])[64];

  278.     int dequant_coeff_pps;     ///< reinit tables when pps changes

  279. 

  280.     int slice_num;

  281.     uint8_t *slice_table_base;

  282.     uint8_t *slice_table;      ///< slice_table_base + 2*mb_stride + 1

  283.     int slice_type;

  284.     int slice_type_fixed;

  285. 

  286.     //interlacing specific flags

  287.     int mb_aff_frame;

  288.     int mb_field_decoding_flag;

  289.     int mb_mbaff;              ///< mb_aff_frame && mb_field_decoding_flag

  290. 

  291.     int sub_mb_type[4];

  292. 

  293.     //POC stuff

  294.     int poc_lsb;

  295.     int poc_msb;

  296.     int delta_poc_bottom;

  297.     int delta_poc[2];

  298.     int frame_num;

  299.     int prev_poc_msb;             ///< poc_msb of the last reference pic for POC type 0

  300.     int prev_poc_lsb;             ///< poc_lsb of the last reference pic for POC type 0

  301.     int frame_num_offset;         ///< for POC type 2

  302.     int prev_frame_num_offset;    ///< for POC type 2

  303.     int prev_frame_num;           ///< frame_num of the last pic for POC type 1/2

  304. 

  305.     /**

  306.      * frame_num for frames or 2*frame_num for field pics.

  307.      */

  308.     int curr_pic_num;

  309. 

  310.     /**

  311.      * max_frame_num or 2*max_frame_num for field pics.

  312.      */

  313.     int max_pic_num;

  314. 

  315.     //Weighted pred stuff

  316.     int use_weight;

  317.     int use_weight_chroma;

  318.     int luma_log2_weight_denom;

  319.     int chroma_log2_weight_denom;

  320.     int luma_weight[2][48];

  321.     int luma_offset[2][48];

  322.     int chroma_weight[2][48][2];

  323.     int chroma_offset[2][48][2];

  324.     int implicit_weight[48][48];

  325. 

  326.     //deblock

  327.     int deblocking_filter;         ///< disable_deblocking_filter_idc with 1<->0

  328.     int slice_alpha_c0_offset;

  329.     int slice_beta_offset;

  330. 

  331.     int redundant_pic_count;

  332. 

  333.     int direct_spatial_mv_pred;

  334.     int dist_scale_factor[16];

  335.     int dist_scale_factor_field[32];

  336.     int map_col_to_list0[2][16];

  337.     int map_col_to_list0_field[2][32];

  338. 

  339.     /**

  340.      * num_ref_idx_l0/1_active_minus1 + 1

  341.      */

  342.     int ref_count[2];            ///< counts frames or fields, depending on current mb mode

  343.     Picture *short_ref[32];

  344.     Picture *long_ref[32];

  345.     Picture default_ref_list[2][32];

  346.     Picture ref_list[2][48];     ///< 0..15: frame refs, 16..47: mbaff field refs

  347.     Picture *delayed_pic[16]; //FIXME size?

  348.     Picture *delayed_output_pic;

  349. 

  350.     /**

  351.      * memory management control operations buffer.

  352.      */

  353.     MMCO mmco[MAX_MMCO_COUNT];

  354.     int mmco_index;

  355. 

  356.     int long_ref_count;  ///< number of actual long term references

  357.     int short_ref_count; ///< number of actual short term references

  358. 

  359.     //data partitioning

  360.     GetBitContext intra_gb;

  361.     GetBitContext inter_gb;

  362.     GetBitContext *intra_gb_ptr;

  363.     GetBitContext *inter_gb_ptr;

  364. 

  365.     DECLARE_ALIGNED_8(DCTELEM, mb[16*24]);

  366. 

  367.     /**

  368.      * Cabac

  369.      */

  370.     CABACContext cabac;

  371.     uint8_t      cabac_state[460];

  372.     int          cabac_init_idc;

  373. 

  374.     /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */

  375.     uint16_t     *cbp_table;

  376.     int cbp;

  377.     int top_cbp;

  378.     int left_cbp;

  379.     /* chroma_pred_mode for i4x4 or i16x16, else 0 */

  380.     uint8_t     *chroma_pred_mode_table;

  381.     int         last_qscale_diff;

  382.     int16_t     (*mvd_table[2])[2];

  383.     DECLARE_ALIGNED_8(int16_t, mvd_cache[2][5*8][2]);

  384.     uint8_t     *direct_table;

  385.     uint8_t     direct_cache[5*8];

  386. 

  387.     uint8_t zigzag_scan[16];

  388.     uint8_t zigzag_scan8x8[64];

  389.     uint8_t zigzag_scan8x8_cavlc[64];

  390.     uint8_t field_scan[16];

  391.     uint8_t field_scan8x8[64];

  392.     uint8_t field_scan8x8_cavlc[64];

  393.     const uint8_t *zigzag_scan_q0;

  394.     const uint8_t *zigzag_scan8x8_q0;

  395.     const uint8_t *zigzag_scan8x8_cavlc_q0;

  396.     const uint8_t *field_scan_q0;

  397.     const uint8_t *field_scan8x8_q0;

  398.     const uint8_t *field_scan8x8_cavlc_q0;

  399. 

  400.     int x264_build;

  401. }H264Context;

  402. 

  403. static VLC coeff_token_vlc[4];

  404. static VLC chroma_dc_coeff_token_vlc;

  405. 

  406. static VLC total_zeros_vlc[15];

  407. static VLC chroma_dc_total_zeros_vlc[3];

  408. 

  409. static VLC run_vlc[6];

  410. static VLC run7_vlc;

  411. 

  412. static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp);

  413. static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc);

  414. static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize);

  415. static void filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize);

  416. 

  417. static always_inline uint32_t pack16to32(int a, int b){

  418. #ifdef WORDS_BIGENDIAN

  419.    return (b&0xFFFF) + (a<<16);

  420. #else

  421.    return (a&0xFFFF) + (b<<16);

  422. #endif

  423. }

  424. 

  425. /**

  426.  * fill a rectangle.

  427.  * @param h height of the rectangle, should be a constant

  428.  * @param w width of the rectangle, should be a constant

  429.  * @param size the size of val (1 or 4), should be a constant

  430.  */

  431. static always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){

  432.     uint8_t *p= (uint8_t*)vp;

  433.     assert(size==1 || size==4);

  434.     assert(w<=4);

  435. 

  436.     w      *= size;

  437.     stride *= size;

  438. 

  439.     assert((((long)vp)&(FFMIN(w, STRIDE_ALIGN)-1)) == 0);

  440.     assert((stride&(w-1))==0);

  441.     if(w==2){

  442.         const uint16_t v= size==4 ? val : val*0x0101;

  443.         *(uint16_t*)(p + 0*stride)= v;

  444.         if(h==1) return;

  445.         *(uint16_t*)(p + 1*stride)= v;

  446.         if(h==2) return;

  447.         *(uint16_t*)(p + 2*stride)=

  448.         *(uint16_t*)(p + 3*stride)= v;

  449.     }else if(w==4){

  450.         const uint32_t v= size==4 ? val : val*0x01010101;

  451.         *(uint32_t*)(p + 0*stride)= v;

  452.         if(h==1) return;

  453.         *(uint32_t*)(p + 1*stride)= v;

  454.         if(h==2) return;

  455.         *(uint32_t*)(p + 2*stride)=

  456.         *(uint32_t*)(p + 3*stride)= v;

  457.     }else if(w==8){

  458.     //gcc can't optimize 64bit math on x86_32

  459. #if defined(ARCH_X86_64) || (defined(MP_WORDSIZE) && MP_WORDSIZE >= 64)

  460.         const uint64_t v= val*0x0100000001ULL;

  461.         *(uint64_t*)(p + 0*stride)= v;

  462.         if(h==1) return;

  463.         *(uint64_t*)(p + 1*stride)= v;

  464.         if(h==2) return;

  465.         *(uint64_t*)(p + 2*stride)=

  466.         *(uint64_t*)(p + 3*stride)= v;

  467.     }else if(w==16){

  468.         const uint64_t v= val*0x0100000001ULL;

  469.         *(uint64_t*)(p + 0+0*stride)=

  470.         *(uint64_t*)(p + 8+0*stride)=

  471.         *(uint64_t*)(p + 0+1*stride)=

  472.         *(uint64_t*)(p + 8+1*stride)= v;

  473.         if(h==2) return;

  474.         *(uint64_t*)(p + 0+2*stride)=

  475.         *(uint64_t*)(p + 8+2*stride)=

  476.         *(uint64_t*)(p + 0+3*stride)=

  477.         *(uint64_t*)(p + 8+3*stride)= v;

  478. #else

  479.         *(uint32_t*)(p + 0+0*stride)=

  480.         *(uint32_t*)(p + 4+0*stride)= val;

  481.         if(h==1) return;

  482.         *(uint32_t*)(p + 0+1*stride)=

  483.         *(uint32_t*)(p + 4+1*stride)= val;

  484.         if(h==2) return;

  485.         *(uint32_t*)(p + 0+2*stride)=

  486.         *(uint32_t*)(p + 4+2*stride)=

  487.         *(uint32_t*)(p + 0+3*stride)=

  488.         *(uint32_t*)(p + 4+3*stride)= val;

  489.     }else if(w==16){

  490.         *(uint32_t*)(p + 0+0*stride)=

  491.         *(uint32_t*)(p + 4+0*stride)=

  492.         *(uint32_t*)(p + 8+0*stride)=

  493.         *(uint32_t*)(p +12+0*stride)=

  494.         *(uint32_t*)(p + 0+1*stride)=

  495.         *(uint32_t*)(p + 4+1*stride)=

  496.         *(uint32_t*)(p + 8+1*stride)=

  497.         *(uint32_t*)(p +12+1*stride)= val;

  498.         if(h==2) return;

  499.         *(uint32_t*)(p + 0+2*stride)=

  500.         *(uint32_t*)(p + 4+2*stride)=

  501.         *(uint32_t*)(p + 8+2*stride)=

  502.         *(uint32_t*)(p +12+2*stride)=

  503.         *(uint32_t*)(p + 0+3*stride)=

  504.         *(uint32_t*)(p + 4+3*stride)=

  505.         *(uint32_t*)(p + 8+3*stride)=

  506.         *(uint32_t*)(p +12+3*stride)= val;

  507. #endif

  508.     }else

  509.         assert(0);

  510.     assert(h==4);

  511. }

  512. 

  513. static void fill_caches(H264Context *h, int mb_type, int for_deblock){

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

  515.     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;

  516.     int topleft_xy, top_xy, topright_xy, left_xy[2];

  517.     int topleft_type, top_type, topright_type, left_type[2];

  518.     int left_block[8];

  519.     int i;

  520. 

  521.     //FIXME deblocking could skip the intra and nnz parts.

  522.     if(for_deblock && (h->slice_num == 1 || h->slice_table[mb_xy] == h->slice_table[mb_xy-s->mb_stride]) && !FRAME_MBAFF)

  523.         return;

  524. 

  525.     //wow what a mess, why didn't they simplify the interlacing&intra stuff, i can't imagine that these complex rules are worth it

  526. 

  527.     top_xy     = mb_xy  - s->mb_stride;

  528.     topleft_xy = top_xy - 1;

  529.     topright_xy= top_xy + 1;

  530.     left_xy[1] = left_xy[0] = mb_xy-1;

  531.     left_block[0]= 0;

  532.     left_block[1]= 1;

  533.     left_block[2]= 2;

  534.     left_block[3]= 3;

  535.     left_block[4]= 7;

  536.     left_block[5]= 10;

  537.     left_block[6]= 8;

  538.     left_block[7]= 11;

  539.     if(FRAME_MBAFF){

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

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

  542.         const int topleft_pair_xy  = top_pair_xy - 1;

  543.         const int topright_pair_xy = top_pair_xy + 1;

  544.         const int topleft_mb_frame_flag  = !IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]);

  545.         const int top_mb_frame_flag      = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);

  546.         const int topright_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]);

  547.         const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);

  548.         const int curr_mb_frame_flag = !IS_INTERLACED(mb_type);

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

  550.         tprintf("fill_caches: curr_mb_frame_flag:%d, left_mb_frame_flag:%d, topleft_mb_frame_flag:%d, top_mb_frame_flag:%d, topright_mb_frame_flag:%d\n", curr_mb_frame_flag, left_mb_frame_flag, topleft_mb_frame_flag, top_mb_frame_flag, topright_mb_frame_flag);

  551.         if (bottom

  552.                 ? !curr_mb_frame_flag // bottom macroblock

  553.                 : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock

  554.                 ) {

  555.             top_xy -= s->mb_stride;

  556.         }

  557.         if (bottom

  558.                 ? !curr_mb_frame_flag // bottom macroblock

  559.                 : (!curr_mb_frame_flag && !topleft_mb_frame_flag) // top macroblock

  560.                 ) {

  561.             topleft_xy -= s->mb_stride;

  562.         }

  563.         if (bottom

  564.                 ? !curr_mb_frame_flag // bottom macroblock

  565.                 : (!curr_mb_frame_flag && !topright_mb_frame_flag) // top macroblock

  566.                 ) {

  567.             topright_xy -= s->mb_stride;

  568.         }

  569.         if (left_mb_frame_flag != curr_mb_frame_flag) {

  570.             left_xy[1] = left_xy[0] = pair_xy - 1;

  571.             if (curr_mb_frame_flag) {

  572.                 if (bottom) {

  573.                     left_block[0]= 2;

  574.                     left_block[1]= 2;

  575.                     left_block[2]= 3;

  576.                     left_block[3]= 3;

  577.                     left_block[4]= 8;

  578.                     left_block[5]= 11;

  579.                     left_block[6]= 8;

  580.                     left_block[7]= 11;

  581.                 } else {

  582.                     left_block[0]= 0;

  583.                     left_block[1]= 0;

  584.                     left_block[2]= 1;

  585.                     left_block[3]= 1;

  586.                     left_block[4]= 7;

  587.                     left_block[5]= 10;

  588.                     left_block[6]= 7;

  589.                     left_block[7]= 10;

  590.                 }

  591.             } else {

  592.                 left_xy[1] += s->mb_stride;

  593.                 //left_block[0]= 0;

  594.                 left_block[1]= 2;

  595.                 left_block[2]= 0;

  596.                 left_block[3]= 2;

  597.                 //left_block[4]= 7;

  598.                 left_block[5]= 10;

  599.                 left_block[6]= 7;

  600.                 left_block[7]= 10;

  601.             }

  602.         }

  603.     }

  604. 

  605.     h->top_mb_xy = top_xy;

  606.     h->left_mb_xy[0] = left_xy[0];

  607.     h->left_mb_xy[1] = left_xy[1];

  608.     if(for_deblock){

  609.         topleft_type = 0;

  610.         topright_type = 0;

  611.         top_type     = h->slice_table[top_xy     ] < 255 ? s->current_picture.mb_type[top_xy]     : 0;

  612.         left_type[0] = h->slice_table[left_xy[0] ] < 255 ? s->current_picture.mb_type[left_xy[0]] : 0;

  613.         left_type[1] = h->slice_table[left_xy[1] ] < 255 ? s->current_picture.mb_type[left_xy[1]] : 0;

  614. 

  615.         if(FRAME_MBAFF && !IS_INTRA(mb_type)){

  616.             int list;

  617.             int v = *(uint16_t*)&h->non_zero_count[mb_xy][14];

  618.             for(i=0; i<16; i++)

  619.                 h->non_zero_count_cache[scan8[i]] = (v>>i)&1;

  620.             for(list=0; list<1+(h->slice_type==B_TYPE); list++){

  621.                 if(USES_LIST(mb_type,list)){

  622.                     uint32_t *src = (uint32_t*)s->current_picture.motion_val[list][h->mb2b_xy[mb_xy]];

  623.                     uint32_t *dst = (uint32_t*)h->mv_cache[list][scan8[0]];

  624.                     int8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]];

  625.                     for(i=0; i<4; i++, dst+=8, src+=h->b_stride){

  626.                         dst[0] = src[0];

  627.                         dst[1] = src[1];

  628.                         dst[2] = src[2];

  629.                         dst[3] = src[3];

  630.                     }

  631.                     *(uint32_t*)&h->ref_cache[list][scan8[ 0]] =

  632.                     *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = pack16to32(ref[0],ref[1])*0x0101;

  633.                     ref += h->b8_stride;

  634.                     *(uint32_t*)&h->ref_cache[list][scan8[ 8]] =

  635.                     *(uint32_t*)&h->ref_cache[list][scan8[10]] = pack16to32(ref[0],ref[1])*0x0101;

  636.                 }else{

  637.                     fill_rectangle(&h-> mv_cache[list][scan8[ 0]], 4, 4, 8, 0, 4);

  638.                     fill_rectangle(&h->ref_cache[list][scan8[ 0]], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1);

  639.                 }

  640.             }

  641.         }

  642.     }else{

  643.         topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0;

  644.         top_type     = h->slice_table[top_xy     ] == h->slice_num ? s->current_picture.mb_type[top_xy]     : 0;

  645.         topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0;

  646.         left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0;

  647.         left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0;

  648.     }

  649. 

  650.     if(IS_INTRA(mb_type)){

  651.         h->topleft_samples_available=

  652.         h->top_samples_available=

  653.         h->left_samples_available= 0xFFFF;

  654.         h->topright_samples_available= 0xEEEA;

  655. 

  656.         if(!IS_INTRA(top_type) && (top_type==0 || h->pps.constrained_intra_pred)){

  657.             h->topleft_samples_available= 0xB3FF;

  658.             h->top_samples_available= 0x33FF;

  659.             h->topright_samples_available= 0x26EA;

  660.         }

  661.         for(i=0; i<2; i++){

  662.             if(!IS_INTRA(left_type[i]) && (left_type[i]==0 || h->pps.constrained_intra_pred)){

  663.                 h->topleft_samples_available&= 0xDF5F;

  664.                 h->left_samples_available&= 0x5F5F;

  665.             }

  666.         }

  667. 

  668.         if(!IS_INTRA(topleft_type) && (topleft_type==0 || h->pps.constrained_intra_pred))

  669.             h->topleft_samples_available&= 0x7FFF;

  670. 

  671.         if(!IS_INTRA(topright_type) && (topright_type==0 || h->pps.constrained_intra_pred))

  672.             h->topright_samples_available&= 0xFBFF;

  673. 

  674.         if(IS_INTRA4x4(mb_type)){

  675.             if(IS_INTRA4x4(top_type)){

  676.                 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4];

  677.                 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5];

  678.                 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6];

  679.                 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3];

  680.             }else{

  681.                 int pred;

  682.                 if(!top_type || (IS_INTER(top_type) && h->pps.constrained_intra_pred))

  683.                     pred= -1;

  684.                 else{

  685.                     pred= 2;

  686.                 }

  687.                 h->intra4x4_pred_mode_cache[4+8*0]=

  688.                 h->intra4x4_pred_mode_cache[5+8*0]=

  689.                 h->intra4x4_pred_mode_cache[6+8*0]=

  690.                 h->intra4x4_pred_mode_cache[7+8*0]= pred;

  691.             }

  692.             for(i=0; i<2; i++){

  693.                 if(IS_INTRA4x4(left_type[i])){

  694.                     h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]];

  695.                     h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]];

  696.                 }else{

  697.                     int pred;

  698.                     if(!left_type[i] || (IS_INTER(left_type[i]) && h->pps.constrained_intra_pred))

  699.                         pred= -1;

  700.                     else{

  701.                         pred= 2;

  702.                     }

  703.                     h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]=

  704.                     h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred;

  705.                 }

  706.             }

  707.         }

  708.     }

  709. 

  710. 

  711. /*

  712. 0 . T T. T T T T

  713. 1 L . .L . . . .

  714. 2 L . .L . . . .

  715. 3 . T TL . . . .

  716. 4 L . .L . . . .

  717. 5 L . .. . . . .

  718. */

  719. //FIXME constraint_intra_pred & partitioning & nnz (lets hope this is just a typo in the spec)

  720.     if(top_type){

  721.         h->non_zero_count_cache[4+8*0]= h->non_zero_count[top_xy][4];

  722.         h->non_zero_count_cache[5+8*0]= h->non_zero_count[top_xy][5];

  723.         h->non_zero_count_cache[6+8*0]= h->non_zero_count[top_xy][6];

  724.         h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3];

  725. 

  726.         h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][9];

  727.         h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8];

  728. 

  729.         h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][12];

  730.         h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11];

  731. 

  732.     }else{

  733.         h->non_zero_count_cache[4+8*0]=

  734.         h->non_zero_count_cache[5+8*0]=

  735.         h->non_zero_count_cache[6+8*0]=

  736.         h->non_zero_count_cache[7+8*0]=

  737. 

  738.         h->non_zero_count_cache[1+8*0]=

  739.         h->non_zero_count_cache[2+8*0]=

  740. 

  741.         h->non_zero_count_cache[1+8*3]=

  742.         h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;

  743. 

  744.     }

  745. 

  746.     for (i=0; i<2; i++) {

  747.         if(left_type[i]){

  748.             h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[0+2*i]];

  749.             h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[1+2*i]];

  750.             h->non_zero_count_cache[0+8*1 +   8*i]= h->non_zero_count[left_xy[i]][left_block[4+2*i]];

  751.             h->non_zero_count_cache[0+8*4 +   8*i]= h->non_zero_count[left_xy[i]][left_block[5+2*i]];

  752.         }else{

  753.             h->non_zero_count_cache[3+8*1 + 2*8*i]=

  754.             h->non_zero_count_cache[3+8*2 + 2*8*i]=

  755.             h->non_zero_count_cache[0+8*1 +   8*i]=

  756.             h->non_zero_count_cache[0+8*4 +   8*i]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;

  757.         }

  758.     }

  759. 

  760.     if( h->pps.cabac ) {

  761.         // top_cbp

  762.         if(top_type) {

  763.             h->top_cbp = h->cbp_table[top_xy];

  764.         } else if(IS_INTRA(mb_type)) {

  765.             h->top_cbp = 0x1C0;

  766.         } else {

  767.             h->top_cbp = 0;

  768.         }

  769.         // left_cbp

  770.         if (left_type[0]) {

  771.             h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0;

  772.         } else if(IS_INTRA(mb_type)) {

  773.             h->left_cbp = 0x1C0;

  774.         } else {

  775.             h->left_cbp = 0;

  776.         }

  777.         if (left_type[0]) {

  778.             h->left_cbp |= ((h->cbp_table[left_xy[0]]>>((left_block[0]&(~1))+1))&0x1) << 1;

  779.         }

  780.         if (left_type[1]) {

  781.             h->left_cbp |= ((h->cbp_table[left_xy[1]]>>((left_block[2]&(~1))+1))&0x1) << 3;

  782.         }

  783.     }

  784. 

  785. #if 1

  786.     if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){

  787.         int list;

  788.         for(list=0; list<1+(h->slice_type==B_TYPE); list++){

  789.             if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){

  790.                 /*if(!h->mv_cache_clean[list]){

  791.                     memset(h->mv_cache [list],  0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all?

  792.                     memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t));

  793.                     h->mv_cache_clean[list]= 1;

  794.                 }*/

  795.                 continue;

  796.             }

  797.             h->mv_cache_clean[list]= 0;

  798. 

  799.             if(USES_LIST(top_type, list)){

  800.                 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;

  801.                 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride;

  802.                 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0];

  803.                 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1];

  804.                 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2];

  805.                 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3];

  806.                 h->ref_cache[list][scan8[0] + 0 - 1*8]=

  807.                 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0];

  808.                 h->ref_cache[list][scan8[0] + 2 - 1*8]=

  809.                 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1];

  810.             }else{

  811.                 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]=

  812.                 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]=

  813.                 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]=

  814.                 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0;

  815.                 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101;

  816.             }

  817. 

  818.             //FIXME unify cleanup or sth

  819.             if(USES_LIST(left_type[0], list)){

  820.                 const int b_xy= h->mb2b_xy[left_xy[0]] + 3;

  821.                 const int b8_xy= h->mb2b8_xy[left_xy[0]] + 1;

  822.                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 0*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0]];

  823.                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1]];

  824.                 h->ref_cache[list][scan8[0] - 1 + 0*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0]>>1)];

  825.                 h->ref_cache[list][scan8[0] - 1 + 1*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[1]>>1)];

  826.             }else{

  827.                 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 0*8]=

  828.                 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 1*8]= 0;

  829.                 h->ref_cache[list][scan8[0] - 1 + 0*8]=

  830.                 h->ref_cache[list][scan8[0] - 1 + 1*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE;

  831.             }

  832. 

  833.             if(USES_LIST(left_type[1], list)){

  834.                 const int b_xy= h->mb2b_xy[left_xy[1]] + 3;

  835.                 const int b8_xy= h->mb2b8_xy[left_xy[1]] + 1;

  836.                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 2*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[2]];

  837.                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 3*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[3]];

  838.                 h->ref_cache[list][scan8[0] - 1 + 2*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[2]>>1)];

  839.                 h->ref_cache[list][scan8[0] - 1 + 3*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[3]>>1)];

  840.             }else{

  841.                 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 2*8]=

  842.                 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 3*8]= 0;

  843.                 h->ref_cache[list][scan8[0] - 1 + 2*8]=

  844.                 h->ref_cache[list][scan8[0] - 1 + 3*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE;

  845.                 assert((!left_type[0]) == (!left_type[1]));

  846.             }

  847. 

  848.             if((for_deblock || (IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred)) && !FRAME_MBAFF)

  849.                 continue;

  850. 

  851.             if(USES_LIST(topleft_type, list)){

  852.                 const int b_xy = h->mb2b_xy[topleft_xy] + 3 + 3*h->b_stride;

  853.                 const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + h->b8_stride;

  854.                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];

  855.                 h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy];

  856.             }else{

  857.                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= 0;

  858.                 h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;

  859.             }

  860. 

  861.             if(USES_LIST(topright_type, list)){

  862.                 const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride;

  863.                 const int b8_xy= h->mb2b8_xy[topright_xy] + h->b8_stride;

  864.                 *(uint32_t*)h->mv_cache[list][scan8[0] + 4 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];

  865.                 h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy];

  866.             }else{

  867.                 *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0;

  868.                 h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;

  869.             }

  870. 

  871.             if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF)

  872.                 continue;

  873. 

  874.             h->ref_cache[list][scan8[5 ]+1] =

  875.             h->ref_cache[list][scan8[7 ]+1] =

  876.             h->ref_cache[list][scan8[13]+1] =  //FIXME remove past 3 (init somewhere else)

  877.             h->ref_cache[list][scan8[4 ]] =

  878.             h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE;

  879.             *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]=

  880.             *(uint32_t*)h->mv_cache [list][scan8[7 ]+1]=

  881.             *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)

  882.             *(uint32_t*)h->mv_cache [list][scan8[4 ]]=

  883.             *(uint32_t*)h->mv_cache [list][scan8[12]]= 0;

  884. 

  885.             if( h->pps.cabac ) {

  886.                 /* XXX beurk, Load mvd */

  887.                 if(USES_LIST(top_type, list)){

  888.                     const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;

  889.                     *(uint32_t*)h->mvd_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 0];

  890.                     *(uint32_t*)h->mvd_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 1];

  891.                     *(uint32_t*)h->mvd_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 2];

  892.                     *(uint32_t*)h->mvd_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 3];

  893.                 }else{

  894.                     *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]=

  895.                     *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]=

  896.                     *(uint32_t*)h->mvd_cache [list][scan8[0] + 2 - 1*8]=

  897.                     *(uint32_t*)h->mvd_cache [list][scan8[0] + 3 - 1*8]= 0;

  898.                 }

  899.                 if(USES_LIST(left_type[0], list)){

  900.                     const int b_xy= h->mb2b_xy[left_xy[0]] + 3;

  901.                     *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 0*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[0]];

  902.                     *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[1]];

  903.                 }else{

  904.                     *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 0*8]=

  905.                     *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 1*8]= 0;

  906.                 }

  907.                 if(USES_LIST(left_type[1], list)){

  908.                     const int b_xy= h->mb2b_xy[left_xy[1]] + 3;

  909.                     *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 2*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[2]];

  910.                     *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 3*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[3]];

  911.                 }else{

  912.                     *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 2*8]=

  913.                     *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 3*8]= 0;

  914.                 }

  915.                 *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]=

  916.                 *(uint32_t*)h->mvd_cache [list][scan8[7 ]+1]=

  917.                 *(uint32_t*)h->mvd_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)

  918.                 *(uint32_t*)h->mvd_cache [list][scan8[4 ]]=

  919.                 *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0;

  920. 

  921.                 if(h->slice_type == B_TYPE){

  922.                     fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1);

  923. 

  924.                     if(IS_DIRECT(top_type)){

  925.                         *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101;

  926.                     }else if(IS_8X8(top_type)){

  927.                         int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride;

  928.                         h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy];

  929.                         h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1];

  930.                     }else{

  931.                         *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0;

  932.                     }

  933. 

  934.                     if(IS_DIRECT(left_type[0]))

  935.                         h->direct_cache[scan8[0] - 1 + 0*8]= 1;

  936.                     else if(IS_8X8(left_type[0]))

  937.                         h->direct_cache[scan8[0] - 1 + 0*8]= h->direct_table[h->mb2b8_xy[left_xy[0]] + 1 + h->b8_stride*(left_block[0]>>1)];

  938.                     else

  939.                         h->direct_cache[scan8[0] - 1 + 0*8]= 0;

  940. 

  941.                     if(IS_DIRECT(left_type[1]))

  942.                         h->direct_cache[scan8[0] - 1 + 2*8]= 1;

  943.                     else if(IS_8X8(left_type[1]))

  944.                         h->direct_cache[scan8[0] - 1 + 2*8]= h->direct_table[h->mb2b8_xy[left_xy[1]] + 1 + h->b8_stride*(left_block[2]>>1)];

  945.                     else

  946.                         h->direct_cache[scan8[0] - 1 + 2*8]= 0;

  947.                 }

  948.             }

  949. 

  950.             if(FRAME_MBAFF){

  951. #define MAP_MVS\

  952.                     MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\

  953.                     MAP_F2F(scan8[0] + 0 - 1*8, top_type)\

  954.                     MAP_F2F(scan8[0] + 1 - 1*8, top_type)\

  955.                     MAP_F2F(scan8[0] + 2 - 1*8, top_type)\

  956.                     MAP_F2F(scan8[0] + 3 - 1*8, top_type)\

  957.                     MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\

  958.                     MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\

  959.                     MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\

  960.                     MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\

  961.                     MAP_F2F(scan8[0] - 1 + 3*8, left_type[1])

  962.                 if(MB_FIELD){

  963. #define MAP_F2F(idx, mb_type)\

  964.                     if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\

  965.                         h->ref_cache[list][idx] <<= 1;\

  966.                         h->mv_cache[list][idx][1] /= 2;\

  967.                         h->mvd_cache[list][idx][1] /= 2;\

  968.                     }

  969.                     MAP_MVS

  970. #undef MAP_F2F

  971.                 }else{

  972. #define MAP_F2F(idx, mb_type)\

  973.                     if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\

  974.                         h->ref_cache[list][idx] >>= 1;\

  975.                         h->mv_cache[list][idx][1] <<= 1;\

  976.                         h->mvd_cache[list][idx][1] <<= 1;\

  977.                     }

  978.                     MAP_MVS

  979. #undef MAP_F2F

  980.                 }

  981.             }

  982.         }

  983.     }

  984. #endif

  985. 

  986.     h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]);

  987. }

  988. 

  989. static inline void write_back_intra_pred_mode(H264Context *h){

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

  991.     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;

  992. 

  993.     h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1];

  994.     h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2];

  995.     h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3];

  996.     h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4];

  997.     h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4];

  998.     h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4];

  999.     h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4];

  1000. }

  1001. 

  1002. /**

  1003.  * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.

  1004.  */

  1005. static inline int check_intra4x4_pred_mode(H264Context *h){

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

  1007.     static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};

  1008.     static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};

  1009.     int i;

  1010. 

  1011.     if(!(h->top_samples_available&0x8000)){

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

  1013.             int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];

  1014.             if(status<0){

  1015.                 av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);

  1016.                 return -1;

  1017.             } else if(status){

  1018.                 h->intra4x4_pred_mode_cache[scan8[0] + i]= status;

  1019.             }

  1020.         }

  1021.     }

  1022. 

  1023.     if(!(h->left_samples_available&0x8000)){

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

  1025.             int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];

  1026.             if(status<0){

  1027.                 av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);

  1028.                 return -1;

  1029.             } else if(status){

  1030.                 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;

  1031.             }

  1032.         }

  1033.     }

  1034. 

  1035.     return 0;

  1036. } //FIXME cleanup like next

  1037. 

  1038. /**

  1039.  * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.

  1040.  */

  1041. static inline int check_intra_pred_mode(H264Context *h, int mode){

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

  1043.     static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};

  1044.     static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};

  1045. 

  1046.     if(mode < 0 || mode > 6) {

  1047.         av_log(h->s.avctx, AV_LOG_ERROR, "out of range intra chroma pred mode at %d %d\n", s->mb_x, s->mb_y);

  1048.         return -1;

  1049.     }

  1050. 

  1051.     if(!(h->top_samples_available&0x8000)){

  1052.         mode= top[ mode ];

  1053.         if(mode<0){

  1054.             av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);

  1055.             return -1;

  1056.         }

  1057.     }

  1058. 

  1059.     if(!(h->left_samples_available&0x8000)){

  1060.         mode= left[ mode ];

  1061.         if(mode<0){

  1062.             av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);

  1063.             return -1;

  1064.         }

  1065.     }

  1066. 

  1067.     return mode;

  1068. }

  1069. 

  1070. /**

  1071.  * gets the predicted intra4x4 prediction mode.

  1072.  */

  1073. static inline int pred_intra_mode(H264Context *h, int n){

  1074.     const int index8= scan8[n];

  1075.     const int left= h->intra4x4_pred_mode_cache[index8 - 1];

  1076.     const int top = h->intra4x4_pred_mode_cache[index8 - 8];

  1077.     const int min= FFMIN(left, top);

  1078. 

  1079.     tprintf("mode:%d %d min:%d\n", left ,top, min);

  1080. 

  1081.     if(min<0) return DC_PRED;

  1082.     else      return min;

  1083. }

  1084. 

  1085. static inline void write_back_non_zero_count(H264Context *h){

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

  1087.     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;

  1088. 

  1089.     h->non_zero_count[mb_xy][0]= h->non_zero_count_cache[7+8*1];

  1090.     h->non_zero_count[mb_xy][1]= h->non_zero_count_cache[7+8*2];

  1091.     h->non_zero_count[mb_xy][2]= h->non_zero_count_cache[7+8*3];

  1092.     h->non_zero_count[mb_xy][3]= h->non_zero_count_cache[7+8*4];

  1093.     h->non_zero_count[mb_xy][4]= h->non_zero_count_cache[4+8*4];

  1094.     h->non_zero_count[mb_xy][5]= h->non_zero_count_cache[5+8*4];

  1095.     h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4];

  1096. 

  1097.     h->non_zero_count[mb_xy][9]= h->non_zero_count_cache[1+8*2];

  1098.     h->non_zero_count[mb_xy][8]= h->non_zero_count_cache[2+8*2];

  1099.     h->non_zero_count[mb_xy][7]= h->non_zero_count_cache[2+8*1];

  1100. 

  1101.     h->non_zero_count[mb_xy][12]=h->non_zero_count_cache[1+8*5];

  1102.     h->non_zero_count[mb_xy][11]=h->non_zero_count_cache[2+8*5];

  1103.     h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4];

  1104. 

  1105.     if(FRAME_MBAFF){

  1106.         // store all luma nnzs, for deblocking

  1107.         int v = 0, i;

  1108.         for(i=0; i<16; i++)

  1109.             v += (!!h->non_zero_count_cache[scan8[i]]) << i;

  1110.         *(uint16_t*)&h->non_zero_count[mb_xy][14] = v;

  1111.     }

  1112. }

  1113. 

  1114. /**

  1115.  * gets the predicted number of non zero coefficients.

  1116.  * @param n block index

  1117.  */

  1118. static inline int pred_non_zero_count(H264Context *h, int n){

  1119.     const int index8= scan8[n];

  1120.     const int left= h->non_zero_count_cache[index8 - 1];

  1121.     const int top = h->non_zero_count_cache[index8 - 8];

  1122.     int i= left + top;

  1123. 

  1124.     if(i<64) i= (i+1)>>1;

  1125. 

  1126.     tprintf("pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);

  1127. 

  1128.     return i&31;

  1129. }

  1130. 

  1131. static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){

  1132.     const int topright_ref= h->ref_cache[list][ i - 8 + part_width ];

  1133. 

  1134.     /* there is no consistent mapping of mvs to neighboring locations that will

  1135.      * make mbaff happy, so we can't move all this logic to fill_caches */

  1136.     if(FRAME_MBAFF){

  1137.         MpegEncContext *s = &h->s;

  1138.         const uint32_t *mb_types = s->current_picture_ptr->mb_type;

  1139.         const int16_t *mv;

  1140.         *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0;

  1141.         *C = h->mv_cache[list][scan8[0]-2];

  1142. 

  1143.         if(!MB_FIELD

  1144.            && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){

  1145.             int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3);

  1146.             if(IS_INTERLACED(mb_types[topright_xy])){

  1147. #define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\

  1148.                 const int x4 = X4, y4 = Y4;\

  1149.                 const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\

  1150.                 if(!USES_LIST(mb_type,list) && !IS_8X8(mb_type))\

  1151.                     return LIST_NOT_USED;\

  1152.                 mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\

  1153.                 h->mv_cache[list][scan8[0]-2][0] = mv[0];\

  1154.                 h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\

  1155.                 return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP;

  1156. 

  1157.                 SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1);

  1158.             }

  1159.         }

  1160.         if(topright_ref == PART_NOT_AVAILABLE

  1161.            && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4

  1162.            && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){

  1163.             if(!MB_FIELD

  1164.                && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){

  1165.                 SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1);

  1166.             }

  1167.             if(MB_FIELD

  1168.                && !IS_INTERLACED(mb_types[h->left_mb_xy[0]])

  1169.                && i >= scan8[0]+8){

  1170.                 // leftshift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's ok.

  1171.                 SET_DIAG_MV(>>1, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2);

  1172.             }

  1173.         }

  1174. #undef SET_DIAG_MV

  1175.     }

  1176. 

  1177.     if(topright_ref != PART_NOT_AVAILABLE){

  1178.         *C= h->mv_cache[list][ i - 8 + part_width ];

  1179.         return topright_ref;

  1180.     }else{

  1181.         tprintf("topright MV not available\n");

  1182. 

  1183.         *C= h->mv_cache[list][ i - 8 - 1 ];

  1184.         return h->ref_cache[list][ i - 8 - 1 ];

  1185.     }

  1186. }

  1187. 

  1188. /**

  1189.  * gets the predicted MV.

  1190.  * @param n the block index

  1191.  * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)

  1192.  * @param mx the x component of the predicted motion vector

  1193.  * @param my the y component of the predicted motion vector

  1194.  */

  1195. static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){

  1196.     const int index8= scan8[n];

  1197.     const int top_ref=      h->ref_cache[list][ index8 - 8 ];

  1198.     const int left_ref=     h->ref_cache[list][ index8 - 1 ];

  1199.     const int16_t * const A= h->mv_cache[list][ index8 - 1 ];

  1200.     const int16_t * const B= h->mv_cache[list][ index8 - 8 ];

  1201.     const int16_t * C;

  1202.     int diagonal_ref, match_count;

  1203. 

  1204.     assert(part_width==1 || part_width==2 || part_width==4);

  1205. 

  1206. /* mv_cache

  1207.   B . . A T T T T

  1208.   U . . L . . , .

  1209.   U . . L . . . .

  1210.   U . . L . . , .

  1211.   . . . L . . . .

  1212. */

  1213. 

  1214.     diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width);

  1215.     match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref);

  1216.     tprintf("pred_motion match_count=%d\n", match_count);

  1217.     if(match_count > 1){ //most common

  1218.         *mx= mid_pred(A[0], B[0], C[0]);

  1219.         *my= mid_pred(A[1], B[1], C[1]);

  1220.     }else if(match_count==1){

  1221.         if(left_ref==ref){

  1222.             *mx= A[0];

  1223.             *my= A[1];

  1224.         }else if(top_ref==ref){

  1225.             *mx= B[0];

  1226.             *my= B[1];

  1227.         }else{

  1228.             *mx= C[0];

  1229.             *my= C[1];

  1230.         }

  1231.     }else{

  1232.         if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){

  1233.             *mx= A[0];

  1234.             *my= A[1];

  1235.         }else{

  1236.             *mx= mid_pred(A[0], B[0], C[0]);

  1237.             *my= mid_pred(A[1], B[1], C[1]);

  1238.         }

  1239.     }

  1240. 

  1241.     tprintf("pred_motion (%2d %2d %2d) (%2d %2d %2d) (%2d %2d %2d) -> (%2d %2d %2d) at %2d %2d %d list %d\n", top_ref, B[0], B[1],                    diagonal_ref, C[0], C[1], left_ref, A[0], A[1], ref, *mx, *my, h->s.mb_x, h->s.mb_y, n, list);

  1242. }

  1243. 

  1244. /**

  1245.  * gets the directionally predicted 16x8 MV.

  1246.  * @param n the block index

  1247.  * @param mx the x component of the predicted motion vector

  1248.  * @param my the y component of the predicted motion vector

  1249.  */

  1250. static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){

  1251.     if(n==0){

  1252.         const int top_ref=      h->ref_cache[list][ scan8[0] - 8 ];

  1253.         const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ];

  1254. 

  1255.         tprintf("pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n", top_ref, B[0], B[1], h->s.mb_x, h->s.mb_y, n, list);

  1256. 

  1257.         if(top_ref == ref){

  1258.             *mx= B[0];

  1259.             *my= B[1];

  1260.             return;

  1261.         }

  1262.     }else{

  1263.         const int left_ref=     h->ref_cache[list][ scan8[8] - 1 ];

  1264.         const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ];

  1265. 

  1266.         tprintf("pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list);

  1267. 

  1268.         if(left_ref == ref){

  1269.             *mx= A[0];

  1270.             *my= A[1];

  1271.             return;

  1272.         }

  1273.     }

  1274. 

  1275.     //RARE

  1276.     pred_motion(h, n, 4, list, ref, mx, my);

  1277. }

  1278. 

  1279. /**

  1280.  * gets the directionally predicted 8x16 MV.

  1281.  * @param n the block index

  1282.  * @param mx the x component of the predicted motion vector

  1283.  * @param my the y component of the predicted motion vector

  1284.  */

  1285. static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){

  1286.     if(n==0){

  1287.         const int left_ref=      h->ref_cache[list][ scan8[0] - 1 ];

  1288.         const int16_t * const A=  h->mv_cache[list][ scan8[0] - 1 ];

  1289. 

  1290.         tprintf("pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list);

  1291. 

  1292.         if(left_ref == ref){

  1293.             *mx= A[0];

  1294.             *my= A[1];

  1295.             return;

  1296.         }

  1297.     }else{

  1298.         const int16_t * C;

  1299.         int diagonal_ref;

  1300. 

  1301.         diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2);

  1302. 

  1303.         tprintf("pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", diagonal_ref, C[0], C[1], h->s.mb_x, h->s.mb_y, n, list);

  1304. 

  1305.         if(diagonal_ref == ref){

  1306.             *mx= C[0];

  1307.             *my= C[1];

  1308.             return;

  1309.         }

  1310.     }

  1311. 

  1312.     //RARE

  1313.     pred_motion(h, n, 2, list, ref, mx, my);

  1314. }

  1315. 

  1316. static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){

  1317.     const int top_ref = h->ref_cache[0][ scan8[0] - 8 ];

  1318.     const int left_ref= h->ref_cache[0][ scan8[0] - 1 ];

  1319. 

  1320.     tprintf("pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y);

  1321. 

  1322.     if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE

  1323.        || (top_ref == 0  && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0)

  1324.        || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){

  1325. 

  1326.         *mx = *my = 0;

  1327.         return;

  1328.     }

  1329. 

  1330.     pred_motion(h, 0, 4, 0, 0, mx, my);

  1331. 

  1332.     return;

  1333. }

  1334. 

  1335. static inline void direct_dist_scale_factor(H264Context * const h){

  1336.     const int poc = h->s.current_picture_ptr->poc;

  1337.     const int poc1 = h->ref_list[1][0].poc;

  1338.     int i;

  1339.     for(i=0; i<h->ref_count[0]; i++){

  1340.         int poc0 = h->ref_list[0][i].poc;

  1341.         int td = clip(poc1 - poc0, -128, 127);

  1342.         if(td == 0 /* FIXME || pic0 is a long-term ref */){

  1343.             h->dist_scale_factor[i] = 256;

  1344.         }else{

  1345.             int tb = clip(poc - poc0, -128, 127);

  1346.             int tx = (16384 + (FFABS(td) >> 1)) / td;

  1347.             h->dist_scale_factor[i] = clip((tb*tx + 32) >> 6, -1024, 1023);

  1348.         }

  1349.     }

  1350.     if(FRAME_MBAFF){

  1351.         for(i=0; i<h->ref_count[0]; i++){

  1352.             h->dist_scale_factor_field[2*i] =

  1353.             h->dist_scale_factor_field[2*i+1] = h->dist_scale_factor[i];

  1354.         }

  1355.     }

  1356. }

  1357. static inline void direct_ref_list_init(H264Context * const h){

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

  1359.     Picture * const ref1 = &h->ref_list[1][0];

  1360.     Picture * const cur = s->current_picture_ptr;

  1361.     int list, i, j;

  1362.     if(cur->pict_type == I_TYPE)

  1363.         cur->ref_count[0] = 0;

  1364.     if(cur->pict_type != B_TYPE)

  1365.         cur->ref_count[1] = 0;

  1366.     for(list=0; list<2; list++){

  1367.         cur->ref_count[list] = h->ref_count[list];

  1368.         for(j=0; j<h->ref_count[list]; j++)

  1369.             cur->ref_poc[list][j] = h->ref_list[list][j].poc;

  1370.     }

  1371.     if(cur->pict_type != B_TYPE || h->direct_spatial_mv_pred)

  1372.         return;

  1373.     for(list=0; list<2; list++){

  1374.         for(i=0; i<ref1->ref_count[list]; i++){

  1375.             const int poc = ref1->ref_poc[list][i];

  1376.             h->map_col_to_list0[list][i] = 0; /* bogus; fills in for missing frames */

  1377.             for(j=0; j<h->ref_count[list]; j++)

  1378.                 if(h->ref_list[list][j].poc == poc){

  1379.                     h->map_col_to_list0[list][i] = j;

  1380.                     break;

  1381.                 }

  1382.         }

  1383.     }

  1384.     if(FRAME_MBAFF){

  1385.         for(list=0; list<2; list++){

  1386.             for(i=0; i<ref1->ref_count[list]; i++){

  1387.                 j = h->map_col_to_list0[list][i];

  1388.                 h->map_col_to_list0_field[list][2*i] = 2*j;

  1389.                 h->map_col_to_list0_field[list][2*i+1] = 2*j+1;

  1390.             }

  1391.         }

  1392.     }

  1393. }

  1394. 

  1395. static inline void pred_direct_motion(H264Context * const h, int *mb_type){

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

  1397.     const int mb_xy =   s->mb_x +   s->mb_y*s->mb_stride;

  1398.     const int b8_xy = 2*s->mb_x + 2*s->mb_y*h->b8_stride;

  1399.     const int b4_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;

  1400.     const int mb_type_col = h->ref_list[1][0].mb_type[mb_xy];

  1401.     const int16_t (*l1mv0)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[0][b4_xy];

  1402.     const int16_t (*l1mv1)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[1][b4_xy];

  1403.     const int8_t *l1ref0 = &h->ref_list[1][0].ref_index[0][b8_xy];

  1404.     const int8_t *l1ref1 = &h->ref_list[1][0].ref_index[1][b8_xy];

  1405.     const int is_b8x8 = IS_8X8(*mb_type);

  1406.     int sub_mb_type;

  1407.     int i8, i4;

  1408. 

  1409. #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)

  1410.     if(IS_8X8(mb_type_col) && !h->sps.direct_8x8_inference_flag){

  1411.         /* FIXME save sub mb types from previous frames (or derive from MVs)

  1412.          * so we know exactly what block size to use */

  1413.         sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */

  1414.         *mb_type =    MB_TYPE_8x8|MB_TYPE_L0L1;

  1415.     }else if(!is_b8x8 && (mb_type_col & MB_TYPE_16x16_OR_INTRA)){

  1416.         sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */

  1417.         *mb_type =    MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */

  1418.     }else{

  1419.         sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */

  1420.         *mb_type =    MB_TYPE_8x8|MB_TYPE_L0L1;

  1421.     }

  1422.     if(!is_b8x8)

  1423.         *mb_type |= MB_TYPE_DIRECT2;

  1424.     if(MB_FIELD)

  1425.         *mb_type |= MB_TYPE_INTERLACED;

  1426. 

  1427.     tprintf("mb_type = %08x, sub_mb_type = %08x, is_b8x8 = %d, mb_type_col = %08x\n", *mb_type, sub_mb_type, is_b8x8, mb_type_col);

  1428. 

  1429.     if(h->direct_spatial_mv_pred){

  1430.         int ref[2];

  1431.         int mv[2][2];

  1432.         int list;

  1433. 

  1434.         /* FIXME interlacing + spatial direct uses wrong colocated block positions */

  1435. 

  1436.         /* ref = min(neighbors) */

  1437.         for(list=0; list<2; list++){

  1438.             int refa = h->ref_cache[list][scan8[0] - 1];

  1439.             int refb = h->ref_cache[list][scan8[0] - 8];

  1440.             int refc = h->ref_cache[list][scan8[0] - 8 + 4];

  1441.             if(refc == -2)

  1442.                 refc = h->ref_cache[list][scan8[0] - 8 - 1];

  1443.             ref[list] = refa;

  1444.             if(ref[list] < 0 || (refb < ref[list] && refb >= 0))

  1445.                 ref[list] = refb;

  1446.             if(ref[list] < 0 || (refc < ref[list] && refc >= 0))

  1447.                 ref[list] = refc;

  1448.             if(ref[list] < 0)

  1449.                 ref[list] = -1;

  1450.         }

  1451. 

  1452.         if(ref[0] < 0 && ref[1] < 0){

  1453.             ref[0] = ref[1] = 0;

  1454.             mv[0][0] = mv[0][1] =

  1455.             mv[1][0] = mv[1][1] = 0;

  1456.         }else{

  1457.             for(list=0; list<2; list++){

  1458.                 if(ref[list] >= 0)

  1459.                     pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]);

  1460.                 else

  1461.                     mv[list][0] = mv[list][1] = 0;

  1462.             }

  1463.         }

  1464. 

  1465.         if(ref[1] < 0){

  1466.             *mb_type &= ~MB_TYPE_P0L1;

  1467.             sub_mb_type &= ~MB_TYPE_P0L1;

  1468.         }else if(ref[0] < 0){

  1469.             *mb_type &= ~MB_TYPE_P0L0;

  1470.             sub_mb_type &= ~MB_TYPE_P0L0;

  1471.         }

  1472. 

  1473.         if(IS_16X16(*mb_type)){

  1474.             fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);

  1475.             fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);

  1476.             if(!IS_INTRA(mb_type_col)

  1477.                && (   (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1)

  1478.                    || (l1ref0[0]  < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1

  1479.                        && (h->x264_build>33 || !h->x264_build)))){

  1480.                 if(ref[0] > 0)

  1481.                     fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4);

  1482.                 else

  1483.                     fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4);

  1484.                 if(ref[1] > 0)

  1485.                     fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4);

  1486.                 else

  1487.                     fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, 0, 4);

  1488.             }else{

  1489.                 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4);

  1490.                 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4);

  1491.             }

  1492.         }else{

  1493.             for(i8=0; i8<4; i8++){

  1494.                 const int x8 = i8&1;

  1495.                 const int y8 = i8>>1;

  1496. 

  1497.                 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))

  1498.                     continue;

  1499.                 h->sub_mb_type[i8] = sub_mb_type;

  1500. 

  1501.                 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4);

  1502.                 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mv[1][0],mv[1][1]), 4);

  1503.                 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);

  1504.                 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);

  1505. 

  1506.                 /* col_zero_flag */

  1507.                 if(!IS_INTRA(mb_type_col) && (   l1ref0[x8 + y8*h->b8_stride] == 0

  1508.                                               || (l1ref0[x8 + y8*h->b8_stride] < 0 && l1ref1[x8 + y8*h->b8_stride] == 0

  1509.                                                   && (h->x264_build>33 || !h->x264_build)))){

  1510.                     const int16_t (*l1mv)[2]= l1ref0[x8 + y8*h->b8_stride] == 0 ? l1mv0 : l1mv1;

  1511.                     if(IS_SUB_8X8(sub_mb_type)){

  1512.                         const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride];

  1513.                         if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){

  1514.                             if(ref[0] == 0)

  1515.                                 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);

  1516.                             if(ref[1] == 0)

  1517.                                 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);

  1518.                         }

  1519.                     }else

  1520.                     for(i4=0; i4<4; i4++){

  1521.                         const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride];

  1522.                         if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){

  1523.                             if(ref[0] == 0)

  1524.                                 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0;

  1525.                             if(ref[1] == 0)

  1526.                                 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0;

  1527.                         }

  1528.                     }

  1529.                 }

  1530.             }

  1531.         }

  1532.     }else{ /* direct temporal mv pred */

  1533.         const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]};

  1534.         const int *dist_scale_factor = h->dist_scale_factor;

  1535. 

  1536.         if(FRAME_MBAFF){

  1537.             if(IS_INTERLACED(*mb_type)){

  1538.                 map_col_to_list0[0] = h->map_col_to_list0_field[0];

  1539.                 map_col_to_list0[1] = h->map_col_to_list0_field[1];

  1540.                 dist_scale_factor = h->dist_scale_factor_field;

  1541.             }

  1542.             if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col)){

  1543.                 /* FIXME assumes direct_8x8_inference == 1 */

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

  1545.                 int mb_types_col[2];

  1546.                 int y_shift;

  1547. 

  1548.                 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1

  1549.                          | (is_b8x8 ? 0 : MB_TYPE_DIRECT2)

  1550.                          | (*mb_type & MB_TYPE_INTERLACED);

  1551.                 sub_mb_type = MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_16x16;

  1552. 

  1553.                 if(IS_INTERLACED(*mb_type)){

  1554.                     /* frame to field scaling */

  1555.                     mb_types_col[0] = h->ref_list[1][0].mb_type[pair_xy];

  1556.                     mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride];

  1557.                     if(s->mb_y&1){

  1558.                         l1ref0 -= 2*h->b8_stride;

  1559.                         l1ref1 -= 2*h->b8_stride;

  1560.                         l1mv0 -= 4*h->b_stride;

  1561.                         l1mv1 -= 4*h->b_stride;

  1562.                     }

  1563.                     y_shift = 0;

  1564. 

  1565.                     if(   (mb_types_col[0] & MB_TYPE_16x16_OR_INTRA)

  1566.                        && (mb_types_col[1] & MB_TYPE_16x16_OR_INTRA)

  1567.                        && !is_b8x8)

  1568.                         *mb_type |= MB_TYPE_16x8;

  1569.                     else

  1570.                         *mb_type |= MB_TYPE_8x8;

  1571.                 }else{

  1572.                     /* field to frame scaling */

  1573.                     /* col_mb_y = (mb_y&~1) + (topAbsDiffPOC < bottomAbsDiffPOC ? 0 : 1)

  1574.                      * but in MBAFF, top and bottom POC are equal */

  1575.                     int dy = (s->mb_y&1) ? 1 : 2;

  1576.                     mb_types_col[0] =

  1577.                     mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride];

  1578.                     l1ref0 += dy*h->b8_stride;

  1579.                     l1ref1 += dy*h->b8_stride;

  1580.                     l1mv0 += 2*dy*h->b_stride;

  1581.                     l1mv1 += 2*dy*h->b_stride;

  1582.                     y_shift = 2;

  1583. 

  1584.                     if((mb_types_col[0] & (MB_TYPE_16x16_OR_INTRA|MB_TYPE_16x8))

  1585.                        && !is_b8x8)

  1586.                         *mb_type |= MB_TYPE_16x16;

  1587.                     else

  1588.                         *mb_type |= MB_TYPE_8x8;

  1589.                 }

  1590. 

  1591.                 for(i8=0; i8<4; i8++){

  1592.                     const int x8 = i8&1;

  1593.                     const int y8 = i8>>1;

  1594.                     int ref0, scale;

  1595.                     const int16_t (*l1mv)[2]= l1mv0;

  1596. 

  1597.                     if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))

  1598.                         continue;

  1599.                     h->sub_mb_type[i8] = sub_mb_type;

  1600. 

  1601.                     fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);

  1602.                     if(IS_INTRA(mb_types_col[y8])){

  1603.                         fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);

  1604.                         fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);

  1605.                         fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);

  1606.                         continue;

  1607.                     }

  1608. 

  1609.                     ref0 = l1ref0[x8 + (y8*2>>y_shift)*h->b8_stride];

  1610.                     if(ref0 >= 0)

  1611.                         ref0 = map_col_to_list0[0][ref0*2>>y_shift];

  1612.                     else{

  1613.                         ref0 = map_col_to_list0[1][l1ref1[x8 + (y8*2>>y_shift)*h->b8_stride]*2>>y_shift];

  1614.                         l1mv= l1mv1;

  1615.                     }

  1616.                     scale = dist_scale_factor[ref0];

  1617.                     fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);

  1618. 

  1619.                     {

  1620.                         const int16_t *mv_col = l1mv[x8*3 + (y8*6>>y_shift)*h->b_stride];

  1621.                         int my_col = (mv_col[1]<<y_shift)/2;

  1622.                         int mx = (scale * mv_col[0] + 128) >> 8;

  1623.                         int my = (scale * my_col + 128) >> 8;

  1624.                         fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);

  1625.                         fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4);

  1626.                     }

  1627.                 }

  1628.                 return;

  1629.             }

  1630.         }

  1631. 

  1632.         /* one-to-one mv scaling */

  1633. 

  1634.         if(IS_16X16(*mb_type)){

  1635.             fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1);

  1636.             if(IS_INTRA(mb_type_col)){

  1637.                 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);

  1638.                 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, 0, 4);

  1639.                 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, 0, 4);

  1640.             }else{

  1641.                 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0]]

  1642.                                                 : map_col_to_list0[1][l1ref1[0]];

  1643.                 const int scale = dist_scale_factor[ref0];

  1644.                 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0];

  1645.                 int mv_l0[2];

  1646.                 mv_l0[0] = (scale * mv_col[0] + 128) >> 8;

  1647.                 mv_l0[1] = (scale * mv_col[1] + 128) >> 8;

  1648.                 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref0, 1);

  1649.                 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0],mv_l0[1]), 4);

  1650.                 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]), 4);

  1651.             }

  1652.         }else{

  1653.             for(i8=0; i8<4; i8++){

  1654.                 const int x8 = i8&1;

  1655.                 const int y8 = i8>>1;

  1656.                 int ref0, scale;

  1657.                 const int16_t (*l1mv)[2]= l1mv0;

  1658. 

  1659.                 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))

  1660.                     continue;

  1661.                 h->sub_mb_type[i8] = sub_mb_type;

  1662.                 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);

  1663.                 if(IS_INTRA(mb_type_col)){

  1664.                     fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);

  1665.                     fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);

  1666.                     fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);

  1667.                     continue;

  1668.                 }

  1669. 

  1670.                 ref0 = l1ref0[x8 + y8*h->b8_stride];

  1671.                 if(ref0 >= 0)

  1672.                     ref0 = map_col_to_list0[0][ref0];

  1673.                 else{

  1674.                     ref0 = map_col_to_list0[1][l1ref1[x8 + y8*h->b8_stride]];

  1675.                     l1mv= l1mv1;

  1676.                 }

  1677.                 scale = dist_scale_factor[ref0];

  1678. 

  1679.                 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);

  1680.                 if(IS_SUB_8X8(sub_mb_type)){

  1681.                     const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride];

  1682.                     int mx = (scale * mv_col[0] + 128) >> 8;

  1683.                     int my = (scale * mv_col[1] + 128) >> 8;

  1684.                     fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);

  1685.                     fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4);

  1686.                 }else

  1687.                 for(i4=0; i4<4; i4++){

  1688.                     const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride];

  1689.                     int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]];

  1690.                     mv_l0[0] = (scale * mv_col[0] + 128) >> 8;

  1691.                     mv_l0[1] = (scale * mv_col[1] + 128) >> 8;

  1692.                     *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] =

  1693.                         pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]);

  1694.                 }

  1695.             }

  1696.         }

  1697.     }

  1698. }

  1699. 

  1700. static inline void write_back_motion(H264Context *h, int mb_type){

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

  1702.     const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;

  1703.     const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride;

  1704.     int list;

  1705. 

  1706.     if(!USES_LIST(mb_type, 0))

  1707.         fill_rectangle(&s->current_picture.ref_index[0][b8_xy], 2, 2, h->b8_stride, (uint8_t)LIST_NOT_USED, 1);

  1708. 

  1709.     for(list=0; list<2; list++){

  1710.         int y;

  1711.         if(!USES_LIST(mb_type, list))

  1712.             continue;

  1713. 

  1714.         for(y=0; y<4; y++){

  1715.             *(uint64_t*)s->current_picture.motion_val[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mv_cache[list][scan8[0]+0 + 8*y];

  1716.             *(uint64_t*)s->current_picture.motion_val[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mv_cache[list][scan8[0]+2 + 8*y];

  1717.         }

  1718.         if( h->pps.cabac ) {

  1719.             if(IS_SKIP(mb_type))

  1720.                 fill_rectangle(h->mvd_table[list][b_xy], 4, 4, h->b_stride, 0, 4);

  1721.             else

  1722.             for(y=0; y<4; y++){

  1723.                 *(uint64_t*)h->mvd_table[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+0 + 8*y];

  1724.                 *(uint64_t*)h->mvd_table[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+2 + 8*y];

  1725.             }

  1726.         }

  1727. 

  1728.         {

  1729.             int8_t *ref_index = &s->current_picture.ref_index[list][b8_xy];

  1730.             ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]];

  1731.             ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]];

  1732.             ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]];

  1733.             ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]];

  1734.         }

  1735.     }

  1736. 

  1737.     if(h->slice_type == B_TYPE && h->pps.cabac){

  1738.         if(IS_8X8(mb_type)){

  1739.             uint8_t *direct_table = &h->direct_table[b8_xy];

  1740.             direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0;

  1741.             direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0;

  1742.             direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0;

  1743.         }

  1744.     }

  1745. }

  1746. 

  1747. /**

  1748.  * Decodes a network abstraction layer unit.

  1749.  * @param consumed is the number of bytes used as input

  1750.  * @param length is the length of the array

  1751.  * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing?

  1752.  * @returns decoded bytes, might be src+1 if no escapes

  1753.  */

  1754. static uint8_t *decode_nal(H264Context *h, uint8_t *src, int *dst_length, int *consumed, int length){

  1755.     int i, si, di;

  1756.     uint8_t *dst;

  1757. 

  1758. //    src[0]&0x80;                //forbidden bit

  1759.     h->nal_ref_idc= src[0]>>5;

  1760.     h->nal_unit_type= src[0]&0x1F;

  1761. 

  1762.     src++; length--;

  1763. #if 0

  1764.     for(i=0; i<length; i++)

  1765.         printf("%2X ", src[i]);

  1766. #endif

  1767.     for(i=0; i+1<length; i+=2){

  1768.         if(src[i]) continue;

  1769.         if(i>0 && src[i-1]==0) i--;

  1770.         if(i+2<length && src[i+1]==0 && src[i+2]<=3){

  1771.             if(src[i+2]!=3){

  1772.                 /* startcode, so we must be past the end */

  1773.                 length=i;

  1774.             }

  1775.             break;

  1776.         }

  1777.     }

  1778. 

  1779.     if(i>=length-1){ //no escaped 0

  1780.         *dst_length= length;

  1781.         *consumed= length+1; //+1 for the header

  1782.         return src;

  1783.     }

  1784. 

  1785.     h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length);

  1786.     dst= h->rbsp_buffer;

  1787. 

  1788. //printf("decoding esc\n");

  1789.     si=di=0;

  1790.     while(si<length){

  1791.         //remove escapes (very rare 1:2^22)

  1792.         if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){

  1793.             if(src[si+2]==3){ //escape

  1794.                 dst[di++]= 0;

  1795.                 dst[di++]= 0;

  1796.                 si+=3;

  1797.                 continue;

  1798.             }else //next start code

  1799.                 break;

  1800.         }

  1801. 

  1802.         dst[di++]= src[si++];

  1803.     }

  1804. 

  1805.     *dst_length= di;

  1806.     *consumed= si + 1;//+1 for the header

  1807. //FIXME store exact number of bits in the getbitcontext (its needed for decoding)

  1808.     return dst;

  1809. }

  1810. 

  1811. #if 0

  1812. /**

  1813.  * @param src the data which should be escaped

  1814.  * @param dst the target buffer, dst+1 == src is allowed as a special case

  1815.  * @param length the length of the src data

  1816.  * @param dst_length the length of the dst array

  1817.  * @returns length of escaped data in bytes or -1 if an error occured

  1818.  */

  1819. static int encode_nal(H264Context *h, uint8_t *dst, uint8_t *src, int length, int dst_length){

  1820.     int i, escape_count, si, di;

  1821.     uint8_t *temp;

  1822. 

  1823.     assert(length>=0);

  1824.     assert(dst_length>0);

  1825. 

  1826.     dst[0]= (h->nal_ref_idc<<5) + h->nal_unit_type;

  1827. 

  1828.     if(length==0) return 1;

  1829. 

  1830.     escape_count= 0;

  1831.     for(i=0; i<length; i+=2){

  1832.         if(src[i]) continue;

  1833.         if(i>0 && src[i-1]==0)

  1834.             i--;

  1835.         if(i+2<length && src[i+1]==0 && src[i+2]<=3){

  1836.             escape_count++;

  1837.             i+=2;

  1838.         }

  1839.     }

  1840. 

  1841.     if(escape_count==0){

  1842.         if(dst+1 != src)

  1843.             memcpy(dst+1, src, length);

  1844.         return length + 1;

  1845.     }

  1846. 

  1847.     if(length + escape_count + 1> dst_length)

  1848.         return -1;

  1849. 

  1850.     //this should be damn rare (hopefully)

  1851. 

  1852.     h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length + escape_count);

  1853.     temp= h->rbsp_buffer;

  1854. //printf("encoding esc\n");

  1855. 

  1856.     si= 0;

  1857.     di= 0;

  1858.     while(si < length){

  1859.         if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){

  1860.             temp[di++]= 0; si++;

  1861.             temp[di++]= 0; si++;

  1862.             temp[di++]= 3;

  1863.             temp[di++]= src[si++];

  1864.         }

  1865.         else

  1866.             temp[di++]= src[si++];

  1867.     }

  1868.     memcpy(dst+1, temp, length+escape_count);

  1869. 

  1870.     assert(di == length+escape_count);

  1871. 

  1872.     return di + 1;

  1873. }

  1874. 

  1875. /**

  1876.  * write 1,10,100,1000,... for alignment, yes its exactly inverse to mpeg4

  1877.  */

  1878. static void encode_rbsp_trailing(PutBitContext *pb){

  1879.     int length;

  1880.     put_bits(pb, 1, 1);

  1881.     length= (-put_bits_count(pb))&7;

  1882.     if(length) put_bits(pb, length, 0);

  1883. }

  1884. #endif

  1885. 

  1886. /**

  1887.  * identifies the exact end of the bitstream

  1888.  * @return the length of the trailing, or 0 if damaged

  1889.  */

  1890. static int decode_rbsp_trailing(uint8_t *src){

  1891.     int v= *src;

  1892.     int r;

  1893. 

  1894.     tprintf("rbsp trailing %X\n", v);

  1895. 

  1896.     for(r=1; r<9; r++){

  1897.         if(v&1) return r;

  1898.         v>>=1;

  1899.     }

  1900.     return 0;

  1901. }

  1902. 

  1903. /**

  1904.  * idct tranforms the 16 dc values and dequantize them.

  1905.  * @param qp quantization parameter

  1906.  */

  1907. static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){

  1908. #define stride 16

  1909.     int i;

  1910.     int temp[16]; //FIXME check if this is a good idea

  1911.     static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};

  1912.     static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};

  1913. 

  1914. //memset(block, 64, 2*256);

  1915. //return;

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

  1917.         const int offset= y_offset[i];

  1918.         const int z0= block[offset+stride*0] + block[offset+stride*4];

  1919.         const int z1= block[offset+stride*0] - block[offset+stride*4];

  1920.         const int z2= block[offset+stride*1] - block[offset+stride*5];

  1921.         const int z3= block[offset+stride*1] + block[offset+stride*5];

  1922. 

  1923.         temp[4*i+0]= z0+z3;

  1924.         temp[4*i+1]= z1+z2;

  1925.         temp[4*i+2]= z1-z2;

  1926.         temp[4*i+3]= z0-z3;

  1927.     }

  1928. 

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

  1930.         const int offset= x_offset[i];

  1931.         const int z0= temp[4*0+i] + temp[4*2+i];

  1932.         const int z1= temp[4*0+i] - temp[4*2+i];

  1933.         const int z2= temp[4*1+i] - temp[4*3+i];

  1934.         const int z3= temp[4*1+i] + temp[4*3+i];

  1935. 

  1936.         block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_resdual

  1937.         block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8));

  1938.         block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8));

  1939.         block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8));

  1940.     }

  1941. }

  1942. 

  1943. #if 0

  1944. /**

  1945.  * dct tranforms the 16 dc values.

  1946.  * @param qp quantization parameter ??? FIXME

  1947.  */

  1948. static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){

  1949. //    const int qmul= dequant_coeff[qp][0];

  1950.     int i;

  1951.     int temp[16]; //FIXME check if this is a good idea

  1952.     static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};

  1953.     static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};

  1954. 

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

  1956.         const int offset= y_offset[i];

  1957.         const int z0= block[offset+stride*0] + block[offset+stride*4];

  1958.         const int z1= block[offset+stride*0] - block[offset+stride*4];

  1959.         const int z2= block[offset+stride*1] - block[offset+stride*5];

  1960.         const int z3= block[offset+stride*1] + block[offset+stride*5];

  1961. 

  1962.         temp[4*i+0]= z0+z3;

  1963.         temp[4*i+1]= z1+z2;

  1964.         temp[4*i+2]= z1-z2;

  1965.         temp[4*i+3]= z0-z3;

  1966.     }

  1967. 

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

  1969.         const int offset= x_offset[i];

  1970.         const int z0= temp[4*0+i] + temp[4*2+i];

  1971.         const int z1= temp[4*0+i] - temp[4*2+i];

  1972.         const int z2= temp[4*1+i] - temp[4*3+i];

  1973.         const int z3= temp[4*1+i] + temp[4*3+i];

  1974. 

  1975.         block[stride*0 +offset]= (z0 + z3)>>1;

  1976.         block[stride*2 +offset]= (z1 + z2)>>1;

  1977.         block[stride*8 +offset]= (z1 - z2)>>1;

  1978.         block[stride*10+offset]= (z0 - z3)>>1;

  1979.     }

  1980. }

  1981. #endif

  1982. 

  1983. #undef xStride

  1984. #undef stride

  1985. 

  1986. static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){

  1987.     const int stride= 16*2;

  1988.     const int xStride= 16;

  1989.     int a,b,c,d,e;

  1990. 

  1991.     a= block[stride*0 + xStride*0];

  1992.     b= block[stride*0 + xStride*1];

  1993.     c= block[stride*1 + xStride*0];

  1994.     d= block[stride*1 + xStride*1];

  1995. 

  1996.     e= a-b;

  1997.     a= a+b;

  1998.     b= c-d;

  1999.     c= c+d;

  2000. 

  2001.     block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7;

  2002.     block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7;

  2003.     block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7;

  2004.     block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7;

  2005. }

  2006. 

  2007. #if 0

  2008. static void chroma_dc_dct_c(DCTELEM *block){

  2009.     const int stride= 16*2;

  2010.     const int xStride= 16;

  2011.     int a,b,c,d,e;

  2012. 

  2013.     a= block[stride*0 + xStride*0];

  2014.     b= block[stride*0 + xStride*1];

  2015.     c= block[stride*1 + xStride*0];

  2016.     d= block[stride*1 + xStride*1];

  2017. 

  2018.     e= a-b;

  2019.     a= a+b;

  2020.     b= c-d;

  2021.     c= c+d;

  2022. 

  2023.     block[stride*0 + xStride*0]= (a+c);

  2024.     block[stride*0 + xStride*1]= (e+b);

  2025.     block[stride*1 + xStride*0]= (a-c);

  2026.     block[stride*1 + xStride*1]= (e-b);

  2027. }

  2028. #endif

  2029. 

  2030. /**

  2031.  * gets the chroma qp.

  2032.  */

  2033. static inline int get_chroma_qp(int chroma_qp_index_offset, int qscale){

  2034. 

  2035.     return chroma_qp[clip(qscale + chroma_qp_index_offset, 0, 51)];

  2036. }

  2037. 

  2038. 

  2039. #if 0

  2040. static void h264_diff_dct_c(DCTELEM *block, uint8_t *src1, uint8_t *src2, int stride){

  2041.     int i;

  2042.     //FIXME try int temp instead of block

  2043. 

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

  2045.         const int d0= src1[0 + i*stride] - src2[0 + i*stride];

  2046.         const int d1= src1[1 + i*stride] - src2[1 + i*stride];

  2047.         const int d2= src1[2 + i*stride] - src2[2 + i*stride];

  2048.         const int d3= src1[3 + i*stride] - src2[3 + i*stride];

  2049.         const int z0= d0 + d3;

  2050.         const int z3= d0 - d3;

  2051.         const int z1= d1 + d2;

  2052.         const int z2= d1 - d2;

  2053. 

  2054.         block[0 + 4*i]=   z0 +   z1;

  2055.         block[1 + 4*i]= 2*z3 +   z2;

  2056.         block[2 + 4*i]=   z0 -   z1;

  2057.         block[3 + 4*i]=   z3 - 2*z2;

  2058.     }

  2059. 

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

  2061.         const int z0= block[0*4 + i] + block[3*4 + i];

  2062.         const int z3= block[0*4 + i] - block[3*4 + i];

  2063.         const int z1= block[1*4 + i] + block[2*4 + i];

  2064.         const int z2= block[1*4 + i] - block[2*4 + i];

  2065. 

  2066.         block[0*4 + i]=   z0 +   z1;

  2067.         block[1*4 + i]= 2*z3 +   z2;

  2068.         block[2*4 + i]=   z0 -   z1;

  2069.         block[3*4 + i]=   z3 - 2*z2;

  2070.     }

  2071. }

  2072. #endif

  2073. 

  2074. //FIXME need to check that this doesnt overflow signed 32 bit for low qp, i am not sure, it's very close

  2075. //FIXME check that gcc inlines this (and optimizes intra & seperate_dc stuff away)

  2076. static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int seperate_dc){

  2077.     int i;

  2078.     const int * const quant_table= quant_coeff[qscale];

  2079.     const int bias= intra ? (1<<QUANT_SHIFT)/3 : (1<<QUANT_SHIFT)/6;

  2080.     const unsigned int threshold1= (1<<QUANT_SHIFT) - bias - 1;

  2081.     const unsigned int threshold2= (threshold1<<1);

  2082.     int last_non_zero;

  2083. 

  2084.     if(seperate_dc){

  2085.         if(qscale<=18){

  2086.             //avoid overflows

  2087.             const int dc_bias= intra ? (1<<(QUANT_SHIFT-2))/3 : (1<<(QUANT_SHIFT-2))/6;

  2088.             const unsigned int dc_threshold1= (1<<(QUANT_SHIFT-2)) - dc_bias - 1;

  2089.             const unsigned int dc_threshold2= (dc_threshold1<<1);

  2090. 

  2091.             int level= block[0]*quant_coeff[qscale+18][0];

  2092.             if(((unsigned)(level+dc_threshold1))>dc_threshold2){

  2093.                 if(level>0){

  2094.                     level= (dc_bias + level)>>(QUANT_SHIFT-2);

  2095.                     block[0]= level;

  2096.                 }else{

  2097.                     level= (dc_bias - level)>>(QUANT_SHIFT-2);

  2098.                     block[0]= -level;

  2099.                 }

  2100. //                last_non_zero = i;

  2101.             }else{

  2102.                 block[0]=0;

  2103.             }

  2104.         }else{

  2105.             const int dc_bias= intra ? (1<<(QUANT_SHIFT+1))/3 : (1<<(QUANT_SHIFT+1))/6;

  2106.             const unsigned int dc_threshold1= (1<<(QUANT_SHIFT+1)) - dc_bias - 1;

  2107.             const unsigned int dc_threshold2= (dc_threshold1<<1);

  2108. 

  2109.             int level= block[0]*quant_table[0];

  2110.             if(((unsigned)(level+dc_threshold1))>dc_threshold2){

  2111.                 if(level>0){

  2112.                     level= (dc_bias + level)>>(QUANT_SHIFT+1);

  2113.                     block[0]= level;

  2114.                 }else{

  2115.                     level= (dc_bias - level)>>(QUANT_SHIFT+1);

  2116.                     block[0]= -level;

  2117.                 }

  2118. //                last_non_zero = i;

  2119.             }else{

  2120.                 block[0]=0;

  2121.             }

  2122.         }

  2123.         last_non_zero= 0;

  2124.         i=1;

  2125.     }else{

  2126.         last_non_zero= -1;

  2127.         i=0;

  2128.     }

  2129. 

  2130.     for(; i<16; i++){

  2131.         const int j= scantable[i];

  2132.         int level= block[j]*quant_table[j];

  2133. 

  2134. //        if(   bias+level >= (1<<(QMAT_SHIFT - 3))

  2135. //           || bias-level >= (1<<(QMAT_SHIFT - 3))){

  2136.         if(((unsigned)(level+threshold1))>threshold2){

  2137.             if(level>0){

  2138.                 level= (bias + level)>>QUANT_SHIFT;

  2139.                 block[j]= level;

  2140.             }else{

  2141.                 level= (bias - level)>>QUANT_SHIFT;

  2142.                 block[j]= -level;

  2143.             }

  2144.             last_non_zero = i;

  2145.         }else{

  2146.             block[j]=0;

  2147.         }

  2148.     }

  2149. 

  2150.     return last_non_zero;

  2151. }

  2152. 

  2153. static void pred4x4_vertical_c(uint8_t *src, uint8_t *topright, int stride){

  2154.     const uint32_t a= ((uint32_t*)(src-stride))[0];

  2155.     ((uint32_t*)(src+0*stride))[0]= a;

  2156.     ((uint32_t*)(src+1*stride))[0]= a;

  2157.     ((uint32_t*)(src+2*stride))[0]= a;

  2158.     ((uint32_t*)(src+3*stride))[0]= a;

  2159. }

  2160. 

  2161. static void pred4x4_horizontal_c(uint8_t *src, uint8_t *topright, int stride){

  2162.     ((uint32_t*)(src+0*stride))[0]= src[-1+0*stride]*0x01010101;

  2163.     ((uint32_t*)(src+1*stride))[0]= src[-1+1*stride]*0x01010101;

  2164.     ((uint32_t*)(src+2*stride))[0]= src[-1+2*stride]*0x01010101;

  2165.     ((uint32_t*)(src+3*stride))[0]= src[-1+3*stride]*0x01010101;

  2166. }

  2167. 

  2168. static void pred4x4_dc_c(uint8_t *src, uint8_t *topright, int stride){

  2169.     const int dc= (  src[-stride] + src[1-stride] + src[2-stride] + src[3-stride]

  2170.                    + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3;

  2171. 

  2172.     ((uint32_t*)(src+0*stride))[0]=

  2173.     ((uint32_t*)(src+1*stride))[0]=

  2174.     ((uint32_t*)(src+2*stride))[0]=

  2175.     ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;

  2176. }

  2177. 

  2178. static void pred4x4_left_dc_c(uint8_t *src, uint8_t *topright, int stride){

  2179.     const int dc= (  src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2;

  2180. 

  2181.     ((uint32_t*)(src+0*stride))[0]=

  2182.     ((uint32_t*)(src+1*stride))[0]=

  2183.     ((uint32_t*)(src+2*stride))[0]=

  2184.     ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;

  2185. }

  2186. 

  2187. static void pred4x4_top_dc_c(uint8_t *src, uint8_t *topright, int stride){

  2188.     const int dc= (  src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2;

  2189. 

  2190.     ((uint32_t*)(src+0*stride))[0]=

  2191.     ((uint32_t*)(src+1*stride))[0]=

  2192.     ((uint32_t*)(src+2*stride))[0]=

  2193.     ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;

  2194. }

  2195. 

  2196. static void pred4x4_128_dc_c(uint8_t *src, uint8_t *topright, int stride){

  2197.     ((uint32_t*)(src+0*stride))[0]=

  2198.     ((uint32_t*)(src+1*stride))[0]=

  2199.     ((uint32_t*)(src+2*stride))[0]=

  2200.     ((uint32_t*)(src+3*stride))[0]= 128U*0x01010101U;

  2201. }

  2202. 

  2203. 

  2204. #define LOAD_TOP_RIGHT_EDGE\

  2205.     const int t4= topright[0];\

  2206.     const int t5= topright[1];\

  2207.     const int t6= topright[2];\

  2208.     const int t7= topright[3];\

  2209. 

  2210. #define LOAD_LEFT_EDGE\

  2211.     const int l0= src[-1+0*stride];\

  2212.     const int l1= src[-1+1*stride];\

  2213.     const int l2= src[-1+2*stride];\

  2214.     const int l3= src[-1+3*stride];\

  2215. 

  2216. #define LOAD_TOP_EDGE\

  2217.     const int t0= src[ 0-1*stride];\

  2218.     const int t1= src[ 1-1*stride];\

  2219.     const int t2= src[ 2-1*stride];\

  2220.     const int t3= src[ 3-1*stride];\

  2221. 

  2222. static void pred4x4_down_right_c(uint8_t *src, uint8_t *topright, int stride){

  2223.     const int lt= src[-1-1*stride];

  2224.     LOAD_TOP_EDGE

  2225.     LOAD_LEFT_EDGE

  2226. 

  2227.     src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2;

  2228.     src[0+2*stride]=

  2229.     src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2;

  2230.     src[0+1*stride]=

  2231.     src[1+2*stride]=

  2232.     src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2;

  2233.     src[0+0*stride]=

  2234.     src[1+1*stride]=

  2235.     src[2+2*stride]=

  2236.     src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2;

  2237.     src[1+0*stride]=

  2238.     src[2+1*stride]=

  2239.     src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2;

  2240.     src[2+0*stride]=

  2241.     src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;

  2242.     src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2;

  2243. }

  2244. 

  2245. static void pred4x4_down_left_c(uint8_t *src, uint8_t *topright, int stride){

  2246.     LOAD_TOP_EDGE

  2247.     LOAD_TOP_RIGHT_EDGE

  2248. //    LOAD_LEFT_EDGE

  2249. 

  2250.     src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2;

  2251.     src[1+0*stride]=

  2252.     src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2;

  2253.     src[2+0*stride]=

  2254.     src[1+1*stride]=

  2255.     src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2;

  2256.     src[3+0*stride]=

  2257.     src[2+1*stride]=

  2258.     src[1+2*stride]=

  2259.     src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2;

  2260.     src[3+1*stride]=

  2261.     src[2+2*stride]=

  2262.     src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2;

  2263.     src[3+2*stride]=

  2264.     src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2;

  2265.     src[3+3*stride]=(t6 + 3*t7 + 2)>>2;

  2266. }

  2267. 

  2268. static void pred4x4_vertical_right_c(uint8_t *src, uint8_t *topright, int stride){

  2269.     const int lt= src[-1-1*stride];

  2270.     LOAD_TOP_EDGE

  2271.     LOAD_LEFT_EDGE

  2272.     const __attribute__((unused)) int unu= l3;

  2273. 

  2274.     src[0+0*stride]=

  2275.     src[1+2*stride]=(lt + t0 + 1)>>1;

  2276.     src[1+0*stride]=

  2277.     src[2+2*stride]=(t0 + t1 + 1)>>1;

  2278.     src[2+0*stride]=

  2279.     src[3+2*stride]=(t1 + t2 + 1)>>1;

  2280.     src[3+0*stride]=(t2 + t3 + 1)>>1;

  2281.     src[0+1*stride]=

  2282.     src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2;

  2283.     src[1+1*stride]=

  2284.     src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2;

  2285.     src[2+1*stride]=

  2286.     src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2;

  2287.     src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2;

  2288.     src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2;

  2289.     src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;

  2290. }

  2291. 

  2292. static void pred4x4_vertical_left_c(uint8_t *src, uint8_t *topright, int stride){

  2293.     LOAD_TOP_EDGE

  2294.     LOAD_TOP_RIGHT_EDGE

  2295.     const __attribute__((unused)) int unu= t7;

  2296. 

  2297.     src[0+0*stride]=(t0 + t1 + 1)>>1;

  2298.     src[1+0*stride]=

  2299.     src[0+2*stride]=(t1 + t2 + 1)>>1;

  2300.     src[2+0*stride]=

  2301.     src[1+2*stride]=(t2 + t3 + 1)>>1;

  2302.     src[3+0*stride]=

  2303.     src[2+2*stride]=(t3 + t4+ 1)>>1;

  2304.     src[3+2*stride]=(t4 + t5+ 1)>>1;

  2305.     src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;

  2306.     src[1+1*stride]=

  2307.     src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2;

  2308.     src[2+1*stride]=

  2309.     src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2;

  2310.     src[3+1*stride]=

  2311.     src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2;

  2312.     src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2;

  2313. }

  2314. 

  2315. static void pred4x4_horizontal_up_c(uint8_t *src, uint8_t *topright, int stride){

  2316.     LOAD_LEFT_EDGE

  2317. 

  2318.     src[0+0*stride]=(l0 + l1 + 1)>>1;

  2319.     src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2;

  2320.     src[2+0*stride]=

  2321.     src[0+1*stride]=(l1 + l2 + 1)>>1;

  2322.     src[3+0*stride]=

  2323.     src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2;

  2324.     src[2+1*stride]=

  2325.     src[0+2*stride]=(l2 + l3 + 1)>>1;

  2326.     src[3+1*stride]=

  2327.     src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2;

  2328.     src[3+2*stride]=

  2329.     src[1+3*stride]=

  2330.     src[0+3*stride]=

  2331.     src[2+2*stride]=

  2332.     src[2+3*stride]=

  2333.     src[3+3*stride]=l3;

  2334. }

  2335. 

  2336. static void pred4x4_horizontal_down_c(uint8_t *src, uint8_t *topright, int stride){

  2337.     const int lt= src[-1-1*stride];

  2338.     LOAD_TOP_EDGE

  2339.     LOAD_LEFT_EDGE

  2340.     const __attribute__((unused)) int unu= t3;

  2341. 

  2342.     src[0+0*stride]=

  2343.     src[2+1*stride]=(lt + l0 + 1)>>1;

  2344.     src[1+0*stride]=

  2345.     src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2;

  2346.     src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2;

  2347.     src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2;

  2348.     src[0+1*stride]=

  2349.     src[2+2*stride]=(l0 + l1 + 1)>>1;

  2350.     src[1+1*stride]=

  2351.     src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2;

  2352.     src[0+2*stride]=

  2353.     src[2+3*stride]=(l1 + l2+ 1)>>1;

  2354.     src[1+2*stride]=

  2355.     src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;

  2356.     src[0+3*stride]=(l2 + l3 + 1)>>1;

  2357.     src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2;

  2358. }

  2359. 

  2360. static void pred16x16_vertical_c(uint8_t *src, int stride){

  2361.     int i;

  2362.     const uint32_t a= ((uint32_t*)(src-stride))[0];

  2363.     const uint32_t b= ((uint32_t*)(src-stride))[1];

  2364.     const uint32_t c= ((uint32_t*)(src-stride))[2];

  2365.     const uint32_t d= ((uint32_t*)(src-stride))[3];

  2366. 

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

  2368.         ((uint32_t*)(src+i*stride))[0]= a;

  2369.         ((uint32_t*)(src+i*stride))[1]= b;

  2370.         ((uint32_t*)(src+i*stride))[2]= c;

  2371.         ((uint32_t*)(src+i*stride))[3]= d;

  2372.     }

  2373. }

  2374. 

  2375. static void pred16x16_horizontal_c(uint8_t *src, int stride){

  2376.     int i;

  2377. 

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

  2379.         ((uint32_t*)(src+i*stride))[0]=

  2380.         ((uint32_t*)(src+i*stride))[1]=

  2381.         ((uint32_t*)(src+i*stride))[2]=

  2382.         ((uint32_t*)(src+i*stride))[3]= src[-1+i*stride]*0x01010101;

  2383.     }

  2384. }

  2385. 

  2386. static void pred16x16_dc_c(uint8_t *src, int stride){

  2387.     int i, dc=0;

  2388. 

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

  2390.         dc+= src[-1+i*stride];

  2391.     }

  2392. 

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

  2394.         dc+= src[i-stride];

  2395.     }

  2396. 

  2397.     dc= 0x01010101*((dc + 16)>>5);

  2398. 

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

  2400.         ((uint32_t*)(src+i*stride))[0]=

  2401.         ((uint32_t*)(src+i*stride))[1]=

  2402.         ((uint32_t*)(src+i*stride))[2]=

  2403.         ((uint32_t*)(src+i*stride))[3]= dc;

  2404.     }

  2405. }

  2406. 

  2407. static void pred16x16_left_dc_c(uint8_t *src, int stride){

  2408.     int i, dc=0;

  2409. 

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

  2411.         dc+= src[-1+i*stride];

  2412.     }

  2413. 

  2414.     dc= 0x01010101*((dc + 8)>>4);

  2415. 

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

  2417.         ((uint32_t*)(src+i*stride))[0]=

  2418.         ((uint32_t*)(src+i*stride))[1]=

  2419.         ((uint32_t*)(src+i*stride))[2]=

  2420.         ((uint32_t*)(src+i*stride))[3]= dc;

  2421.     }

  2422. }

  2423. 

  2424. static void pred16x16_top_dc_c(uint8_t *src, int stride){

  2425.     int i, dc=0;

  2426. 

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

  2428.         dc+= src[i-stride];

  2429.     }

  2430.     dc= 0x01010101*((dc + 8)>>4);

  2431. 

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

  2433.         ((uint32_t*)(src+i*stride))[0]=

  2434.         ((uint32_t*)(src+i*stride))[1]=

  2435.         ((uint32_t*)(src+i*stride))[2]=

  2436.         ((uint32_t*)(src+i*stride))[3]= dc;

  2437.     }

  2438. }

  2439. 

  2440. static void pred16x16_128_dc_c(uint8_t *src, int stride){

  2441.     int i;

  2442. 

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

  2444.         ((uint32_t*)(src+i*stride))[0]=

  2445.         ((uint32_t*)(src+i*stride))[1]=

  2446.         ((uint32_t*)(src+i*stride))[2]=

  2447.         ((uint32_t*)(src+i*stride))[3]= 0x01010101U*128U;

  2448.     }

  2449. }

  2450. 

  2451. static inline void pred16x16_plane_compat_c(uint8_t *src, int stride, const int svq3){

  2452.   int i, j, k;

  2453.   int a;

  2454.   uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  2455.   const uint8_t * const src0 = src+7-stride;

  2456.   const uint8_t *src1 = src+8*stride-1;

  2457.   const uint8_t *src2 = src1-2*stride;      // == src+6*stride-1;

  2458.   int H = src0[1] - src0[-1];

  2459.   int V = src1[0] - src2[ 0];

  2460.   for(k=2; k<=8; ++k) {

  2461.     src1 += stride; src2 -= stride;

  2462.     H += k*(src0[k] - src0[-k]);

  2463.     V += k*(src1[0] - src2[ 0]);

  2464.   }

  2465.   if(svq3){

  2466.     H = ( 5*(H/4) ) / 16;

  2467.     V = ( 5*(V/4) ) / 16;

  2468. 

  2469.     /* required for 100% accuracy */

  2470.     i = H; H = V; V = i;

  2471.   }else{

  2472.     H = ( 5*H+32 ) >> 6;

  2473.     V = ( 5*V+32 ) >> 6;

  2474.   }

  2475. 

  2476.   a = 16*(src1[0] + src2[16] + 1) - 7*(V+H);

  2477.   for(j=16; j>0; --j) {

  2478.     int b = a;

  2479.     a += V;

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

  2481.       src[16+i] = cm[ (b    ) >> 5 ];

  2482.       src[17+i] = cm[ (b+  H) >> 5 ];

  2483.       src[18+i] = cm[ (b+2*H) >> 5 ];

  2484.       src[19+i] = cm[ (b+3*H) >> 5 ];

  2485.       b += 4*H;

  2486.     }

  2487.     src += stride;

  2488.   }

  2489. }

  2490. 

  2491. static void pred16x16_plane_c(uint8_t *src, int stride){

  2492.     pred16x16_plane_compat_c(src, stride, 0);

  2493. }

  2494. 

  2495. static void pred8x8_vertical_c(uint8_t *src, int stride){

  2496.     int i;

  2497.     const uint32_t a= ((uint32_t*)(src-stride))[0];

  2498.     const uint32_t b= ((uint32_t*)(src-stride))[1];

  2499. 

  2500.     for(i=0; i<8; i++){

  2501.         ((uint32_t*)(src+i*stride))[0]= a;

  2502.         ((uint32_t*)(src+i*stride))[1]= b;

  2503.     }

  2504. }

  2505. 

  2506. static void pred8x8_horizontal_c(uint8_t *src, int stride){

  2507.     int i;

  2508. 

  2509.     for(i=0; i<8; i++){

  2510.         ((uint32_t*)(src+i*stride))[0]=

  2511.         ((uint32_t*)(src+i*stride))[1]= src[-1+i*stride]*0x01010101;

  2512.     }

  2513. }

  2514. 

  2515. static void pred8x8_128_dc_c(uint8_t *src, int stride){

  2516.     int i;

  2517. 

  2518.     for(i=0; i<8; i++){

  2519.         ((uint32_t*)(src+i*stride))[0]=

  2520.         ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U;

  2521.     }

  2522. }

  2523. 

  2524. static void pred8x8_left_dc_c(uint8_t *src, int stride){

  2525.     int i;

  2526.     int dc0, dc2;

  2527. 

  2528.     dc0=dc2=0;

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

  2530.         dc0+= src[-1+i*stride];

  2531.         dc2+= src[-1+(i+4)*stride];

  2532.     }

  2533.     dc0= 0x01010101*((dc0 + 2)>>2);

  2534.     dc2= 0x01010101*((dc2 + 2)>>2);

  2535. 

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

  2537.         ((uint32_t*)(src+i*stride))[0]=

  2538.         ((uint32_t*)(src+i*stride))[1]= dc0;

  2539.     }

  2540.     for(i=4; i<8; i++){

  2541.         ((uint32_t*)(src+i*stride))[0]=

  2542.         ((uint32_t*)(src+i*stride))[1]= dc2;

  2543.     }

  2544. }

  2545. 

  2546. static void pred8x8_top_dc_c(uint8_t *src, int stride){

  2547.     int i;

  2548.     int dc0, dc1;

  2549. 

  2550.     dc0=dc1=0;

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

  2552.         dc0+= src[i-stride];

  2553.         dc1+= src[4+i-stride];

  2554.     }

  2555.     dc0= 0x01010101*((dc0 + 2)>>2);

  2556.     dc1= 0x01010101*((dc1 + 2)>>2);

  2557. 

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

  2559.         ((uint32_t*)(src+i*stride))[0]= dc0;

  2560.         ((uint32_t*)(src+i*stride))[1]= dc1;

  2561.     }

  2562.     for(i=4; i<8; i++){

  2563.         ((uint32_t*)(src+i*stride))[0]= dc0;

  2564.         ((uint32_t*)(src+i*stride))[1]= dc1;

  2565.     }

  2566. }

  2567. 

  2568. 

  2569. static void pred8x8_dc_c(uint8_t *src, int stride){

  2570.     int i;

  2571.     int dc0, dc1, dc2, dc3;

  2572. 

  2573.     dc0=dc1=dc2=0;

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

  2575.         dc0+= src[-1+i*stride] + src[i-stride];

  2576.         dc1+= src[4+i-stride];

  2577.         dc2+= src[-1+(i+4)*stride];

  2578.     }

  2579.     dc3= 0x01010101*((dc1 + dc2 + 4)>>3);

  2580.     dc0= 0x01010101*((dc0 + 4)>>3);

  2581.     dc1= 0x01010101*((dc1 + 2)>>2);

  2582.     dc2= 0x01010101*((dc2 + 2)>>2);

  2583. 

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

  2585.         ((uint32_t*)(src+i*stride))[0]= dc0;

  2586.         ((uint32_t*)(src+i*stride))[1]= dc1;

  2587.     }

  2588.     for(i=4; i<8; i++){

  2589.         ((uint32_t*)(src+i*stride))[0]= dc2;

  2590.         ((uint32_t*)(src+i*stride))[1]= dc3;

  2591.     }

  2592. }

  2593. 

  2594. static void pred8x8_plane_c(uint8_t *src, int stride){

  2595.   int j, k;

  2596.   int a;

  2597.   uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  2598.   const uint8_t * const src0 = src+3-stride;

  2599.   const uint8_t *src1 = src+4*stride-1;

  2600.   const uint8_t *src2 = src1-2*stride;      // == src+2*stride-1;

  2601.   int H = src0[1] - src0[-1];

  2602.   int V = src1[0] - src2[ 0];

  2603.   for(k=2; k<=4; ++k) {

  2604.     src1 += stride; src2 -= stride;

  2605.     H += k*(src0[k] - src0[-k]);

  2606.     V += k*(src1[0] - src2[ 0]);

  2607.   }

  2608.   H = ( 17*H+16 ) >> 5;

  2609.   V = ( 17*V+16 ) >> 5;

  2610. 

  2611.   a = 16*(src1[0] + src2[8]+1) - 3*(V+H);

  2612.   for(j=8; j>0; --j) {

  2613.     int b = a;

  2614.     a += V;

  2615.     src[0] = cm[ (b    ) >> 5 ];

  2616.     src[1] = cm[ (b+  H) >> 5 ];

  2617.     src[2] = cm[ (b+2*H) >> 5 ];

  2618.     src[3] = cm[ (b+3*H) >> 5 ];

  2619.     src[4] = cm[ (b+4*H) >> 5 ];

  2620.     src[5] = cm[ (b+5*H) >> 5 ];

  2621.     src[6] = cm[ (b+6*H) >> 5 ];

  2622.     src[7] = cm[ (b+7*H) >> 5 ];

  2623.     src += stride;

  2624.   }

  2625. }

  2626. 

  2627. #define SRC(x,y) src[(x)+(y)*stride]

  2628. #define PL(y) \

  2629.     const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2;

  2630. #define PREDICT_8x8_LOAD_LEFT \

  2631.     const int l0 = ((has_topleft ? SRC(-1,-1) : SRC(-1,0)) \

  2632.                      + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; \

  2633.     PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) \

  2634.     const int l7 attribute_unused = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2

  2635. 

  2636. #define PT(x) \

  2637.     const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;

  2638. #define PREDICT_8x8_LOAD_TOP \

  2639.     const int t0 = ((has_topleft ? SRC(-1,-1) : SRC(0,-1)) \

  2640.                      + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; \

  2641.     PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) \

  2642.     const int t7 attribute_unused = ((has_topright ? SRC(8,-1) : SRC(7,-1)) \

  2643.                      + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2

  2644. 

  2645. #define PTR(x) \

  2646.     t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;

  2647. #define PREDICT_8x8_LOAD_TOPRIGHT \

  2648.     int t8, t9, t10, t11, t12, t13, t14, t15; \

  2649.     if(has_topright) { \

  2650.         PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) \

  2651.         t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; \

  2652.     } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1);

  2653. 

  2654. #define PREDICT_8x8_LOAD_TOPLEFT \

  2655.     const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2

  2656. 

  2657. #define PREDICT_8x8_DC(v) \

  2658.     int y; \

  2659.     for( y = 0; y < 8; y++ ) { \

  2660.         ((uint32_t*)src)[0] = \

  2661.         ((uint32_t*)src)[1] = v; \

  2662.         src += stride; \

  2663.     }

  2664. 

  2665. static void pred8x8l_128_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  2666. {

  2667.     PREDICT_8x8_DC(0x80808080);

  2668. }

  2669. static void pred8x8l_left_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  2670. {

  2671.     PREDICT_8x8_LOAD_LEFT;

  2672.     const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3) * 0x01010101;

  2673.     PREDICT_8x8_DC(dc);

  2674. }

  2675. static void pred8x8l_top_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  2676. {

  2677.     PREDICT_8x8_LOAD_TOP;

  2678.     const uint32_t dc = ((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3) * 0x01010101;

  2679.     PREDICT_8x8_DC(dc);

  2680. }

  2681. static void pred8x8l_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  2682. {

  2683.     PREDICT_8x8_LOAD_LEFT;

  2684.     PREDICT_8x8_LOAD_TOP;

  2685.     const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7

  2686.                          +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4) * 0x01010101;

  2687.     PREDICT_8x8_DC(dc);

  2688. }

  2689. static void pred8x8l_horizontal_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  2690. {

  2691.     PREDICT_8x8_LOAD_LEFT;

  2692. #define ROW(y) ((uint32_t*)(src+y*stride))[0] =\

  2693.                ((uint32_t*)(src+y*stride))[1] = 0x01010101 * l##y

  2694.     ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7);

  2695. #undef ROW

  2696. }

  2697. static void pred8x8l_vertical_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  2698. {

  2699.     int y;

  2700.     PREDICT_8x8_LOAD_TOP;

  2701.     src[0] = t0;

  2702.     src[1] = t1;

  2703.     src[2] = t2;

  2704.     src[3] = t3;

  2705.     src[4] = t4;

  2706.     src[5] = t5;

  2707.     src[6] = t6;

  2708.     src[7] = t7;

  2709.     for( y = 1; y < 8; y++ )

  2710.         *(uint64_t*)(src+y*stride) = *(uint64_t*)src;

  2711. }

  2712. static void pred8x8l_down_left_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  2713. {

  2714.     PREDICT_8x8_LOAD_TOP;

  2715.     PREDICT_8x8_LOAD_TOPRIGHT;

  2716.     SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2;

  2717.     SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2;

  2718.     SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2;

  2719.     SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2;

  2720.     SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2;

  2721.     SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2;

  2722.     SRC(0,6)=SRC(1,5)=SRC(2,4)=SRC(3,3)=SRC(4,2)=SRC(5,1)=SRC(6,0)= (t6 + 2*t7 + t8 + 2) >> 2;

  2723.     SRC(0,7)=SRC(1,6)=SRC(2,5)=SRC(3,4)=SRC(4,3)=SRC(5,2)=SRC(6,1)=SRC(7,0)= (t7 + 2*t8 + t9 + 2) >> 2;

  2724.     SRC(1,7)=SRC(2,6)=SRC(3,5)=SRC(4,4)=SRC(5,3)=SRC(6,2)=SRC(7,1)= (t8 + 2*t9 + t10 + 2) >> 2;

  2725.     SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2;

  2726.     SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2;

  2727.     SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2;

  2728.     SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2;

  2729.     SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2;

  2730.     SRC(7,7)= (t14 + 3*t15 + 2) >> 2;

  2731. }

  2732. static void pred8x8l_down_right_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  2733. {

  2734.     PREDICT_8x8_LOAD_TOP;

  2735.     PREDICT_8x8_LOAD_LEFT;

  2736.     PREDICT_8x8_LOAD_TOPLEFT;

  2737.     SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2;

  2738.     SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2;

  2739.     SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2;

  2740.     SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2;

  2741.     SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2;

  2742.     SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2;

  2743.     SRC(0,1)=SRC(1,2)=SRC(2,3)=SRC(3,4)=SRC(4,5)=SRC(5,6)=SRC(6,7)= (l1 + 2*l0 + lt + 2) >> 2;

  2744.     SRC(0,0)=SRC(1,1)=SRC(2,2)=SRC(3,3)=SRC(4,4)=SRC(5,5)=SRC(6,6)=SRC(7,7)= (l0 + 2*lt + t0 + 2) >> 2;

  2745.     SRC(1,0)=SRC(2,1)=SRC(3,2)=SRC(4,3)=SRC(5,4)=SRC(6,5)=SRC(7,6)= (lt + 2*t0 + t1 + 2) >> 2;

  2746.     SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2;

  2747.     SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2;

  2748.     SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2;

  2749.     SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2;

  2750.     SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2;

  2751.     SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2;

  2752. 

  2753. }

  2754. static void pred8x8l_vertical_right_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  2755. {

  2756.     PREDICT_8x8_LOAD_TOP;

  2757.     PREDICT_8x8_LOAD_LEFT;

  2758.     PREDICT_8x8_LOAD_TOPLEFT;

  2759.     SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2;

  2760.     SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2;

  2761.     SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2;

  2762.     SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2;

  2763.     SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2;

  2764.     SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2;

  2765.     SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2;

  2766.     SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1;

  2767.     SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2;

  2768.     SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1;

  2769.     SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2;

  2770.     SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1;

  2771.     SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2;

  2772.     SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1;

  2773.     SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2;

  2774.     SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1;

  2775.     SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2;

  2776.     SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1;

  2777.     SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2;

  2778.     SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1;

  2779.     SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2;

  2780.     SRC(7,0)= (t6 + t7 + 1) >> 1;

  2781. }

  2782. static void pred8x8l_horizontal_down_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  2783. {

  2784.     PREDICT_8x8_LOAD_TOP;

  2785.     PREDICT_8x8_LOAD_LEFT;

  2786.     PREDICT_8x8_LOAD_TOPLEFT;

  2787.     SRC(0,7)= (l6 + l7 + 1) >> 1;

  2788.     SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2;

  2789.     SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1;

  2790.     SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2;

  2791.     SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1;

  2792.     SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2;

  2793.     SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1;

  2794.     SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2;

  2795.     SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1;

  2796.     SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2;

  2797.     SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1;

  2798.     SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2;

  2799.     SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1;

  2800.     SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2;

  2801.     SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1;

  2802.     SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2;

  2803.     SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2;

  2804.     SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2;

  2805.     SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2;

  2806.     SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2;

  2807.     SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2;

  2808.     SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2;

  2809. }

  2810. static void pred8x8l_vertical_left_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  2811. {

  2812.     PREDICT_8x8_LOAD_TOP;

  2813.     PREDICT_8x8_LOAD_TOPRIGHT;

  2814.     SRC(0,0)= (t0 + t1 + 1) >> 1;

  2815.     SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2;

  2816.     SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1;

  2817.     SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2;

  2818.     SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1;

  2819.     SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2;

  2820.     SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1;

  2821.     SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2;

  2822.     SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1;

  2823.     SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2;

  2824.     SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1;

  2825.     SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2;

  2826.     SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1;

  2827.     SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2;

  2828.     SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1;

  2829.     SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2;

  2830.     SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1;

  2831.     SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2;

  2832.     SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1;

  2833.     SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2;

  2834.     SRC(7,6)= (t10 + t11 + 1) >> 1;

  2835.     SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2;

  2836. }

  2837. static void pred8x8l_horizontal_up_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  2838. {

  2839.     PREDICT_8x8_LOAD_LEFT;

  2840.     SRC(0,0)= (l0 + l1 + 1) >> 1;

  2841.     SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2;

  2842.     SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1;

  2843.     SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2;

  2844.     SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1;

  2845.     SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2;

  2846.     SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1;

  2847.     SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2;

  2848.     SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1;

  2849.     SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2;

  2850.     SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1;

  2851.     SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2;

  2852.     SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1;

  2853.     SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2;

  2854.     SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)=

  2855.     SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)=

  2856.     SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)=

  2857.     SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7;

  2858. }

  2859. #undef PREDICT_8x8_LOAD_LEFT

  2860. #undef PREDICT_8x8_LOAD_TOP

  2861. #undef PREDICT_8x8_LOAD_TOPLEFT

  2862. #undef PREDICT_8x8_LOAD_TOPRIGHT

  2863. #undef PREDICT_8x8_DC

  2864. #undef PTR

  2865. #undef PT

  2866. #undef PL

  2867. #undef SRC

  2868. 

  2869. static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,

  2870.                            uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

  2871.                            int src_x_offset, int src_y_offset,

  2872.                            qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){

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

  2874.     const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;

  2875.     int my=       h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;

  2876.     const int luma_xy= (mx&3) + ((my&3)<<2);

  2877.     uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize;

  2878.     uint8_t * src_cb, * src_cr;

  2879.     int extra_width= h->emu_edge_width;

  2880.     int extra_height= h->emu_edge_height;

  2881.     int emu=0;

  2882.     const int full_mx= mx>>2;

  2883.     const int full_my= my>>2;

  2884.     const int pic_width  = 16*s->mb_width;

  2885.     const int pic_height = 16*s->mb_height >> MB_MBAFF;

  2886. 

  2887.     if(!pic->data[0])

  2888.         return;

  2889. 

  2890.     if(mx&7) extra_width -= 3;

  2891.     if(my&7) extra_height -= 3;

  2892. 

  2893.     if(   full_mx < 0-extra_width

  2894.        || full_my < 0-extra_height

  2895.        || full_mx + 16/*FIXME*/ > pic_width + extra_width

  2896.        || full_my + 16/*FIXME*/ > pic_height + extra_height){

  2897.         ff_emulated_edge_mc(s->edge_emu_buffer, src_y - 2 - 2*h->mb_linesize, h->mb_linesize, 16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);

  2898.             src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize;

  2899.         emu=1;

  2900.     }

  2901. 

  2902.     qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps?

  2903.     if(!square){

  2904.         qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize);

  2905.     }

  2906. 

  2907.     if(s->flags&CODEC_FLAG_GRAY) return;

  2908. 

  2909.     if(MB_MBAFF){

  2910.         // chroma offset when predicting from a field of opposite parity

  2911.         my += 2 * ((s->mb_y & 1) - (h->ref_cache[list][scan8[n]] & 1));

  2912.         emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1);

  2913.     }

  2914.     src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize;

  2915.     src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize;

  2916. 

  2917.     if(emu){

  2918.         ff_emulated_edge_mc(s->edge_emu_buffer, src_cb, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);

  2919.             src_cb= s->edge_emu_buffer;

  2920.     }

  2921.     chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7);

  2922. 

  2923.     if(emu){

  2924.         ff_emulated_edge_mc(s->edge_emu_buffer, src_cr, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);

  2925.             src_cr= s->edge_emu_buffer;

  2926.     }

  2927.     chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7);

  2928. }

  2929. 

  2930. static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta,

  2931.                            uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

  2932.                            int x_offset, int y_offset,

  2933.                            qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,

  2934.                            qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,

  2935.                            int list0, int list1){

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

  2937.     qpel_mc_func *qpix_op=  qpix_put;

  2938.     h264_chroma_mc_func chroma_op= chroma_put;

  2939. 

  2940.     dest_y  += 2*x_offset + 2*y_offset*h->  mb_linesize;

  2941.     dest_cb +=   x_offset +   y_offset*h->mb_uvlinesize;

  2942.     dest_cr +=   x_offset +   y_offset*h->mb_uvlinesize;

  2943.     x_offset += 8*s->mb_x;

  2944.     y_offset += 8*(s->mb_y >> MB_MBAFF);

  2945. 

  2946.     if(list0){

  2947.         Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];

  2948.         mc_dir_part(h, ref, n, square, chroma_height, delta, 0,

  2949.                            dest_y, dest_cb, dest_cr, x_offset, y_offset,

  2950.                            qpix_op, chroma_op);

  2951. 

  2952.         qpix_op=  qpix_avg;

  2953.         chroma_op= chroma_avg;

  2954.     }

  2955. 

  2956.     if(list1){

  2957.         Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];

  2958.         mc_dir_part(h, ref, n, square, chroma_height, delta, 1,

  2959.                            dest_y, dest_cb, dest_cr, x_offset, y_offset,

  2960.                            qpix_op, chroma_op);

  2961.     }

  2962. }

  2963. 

  2964. static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta,

  2965.                            uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

  2966.                            int x_offset, int y_offset,

  2967.                            qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,

  2968.                            h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,

  2969.                            h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,

  2970.                            int list0, int list1){

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

  2972. 

  2973.     dest_y  += 2*x_offset + 2*y_offset*h->  mb_linesize;

  2974.     dest_cb +=   x_offset +   y_offset*h->mb_uvlinesize;

  2975.     dest_cr +=   x_offset +   y_offset*h->mb_uvlinesize;

  2976.     x_offset += 8*s->mb_x;

  2977.     y_offset += 8*(s->mb_y >> MB_MBAFF);

  2978. 

  2979.     if(list0 && list1){

  2980.         /* don't optimize for luma-only case, since B-frames usually

  2981.          * use implicit weights => chroma too. */

  2982.         uint8_t *tmp_cb = s->obmc_scratchpad;

  2983.         uint8_t *tmp_cr = s->obmc_scratchpad + 8;

  2984.         uint8_t *tmp_y  = s->obmc_scratchpad + 8*h->mb_uvlinesize;

  2985.         int refn0 = h->ref_cache[0][ scan8[n] ];

  2986.         int refn1 = h->ref_cache[1][ scan8[n] ];

  2987. 

  2988.         mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0,

  2989.                     dest_y, dest_cb, dest_cr,

  2990.                     x_offset, y_offset, qpix_put, chroma_put);

  2991.         mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1,

  2992.                     tmp_y, tmp_cb, tmp_cr,

  2993.                     x_offset, y_offset, qpix_put, chroma_put);

  2994. 

  2995.         if(h->use_weight == 2){

  2996.             int weight0 = h->implicit_weight[refn0][refn1];

  2997.             int weight1 = 64 - weight0;

  2998.             luma_weight_avg(  dest_y,  tmp_y,  h->  mb_linesize, 5, weight0, weight1, 0);

  2999.             chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0);

  3000.             chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0);

  3001.         }else{

  3002.             luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom,

  3003.                             h->luma_weight[0][refn0], h->luma_weight[1][refn1],

  3004.                             h->luma_offset[0][refn0] + h->luma_offset[1][refn1]);

  3005.             chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,

  3006.                             h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0],

  3007.                             h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]);

  3008.             chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,

  3009.                             h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1],

  3010.                             h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]);

  3011.         }

  3012.     }else{

  3013.         int list = list1 ? 1 : 0;

  3014.         int refn = h->ref_cache[list][ scan8[n] ];

  3015.         Picture *ref= &h->ref_list[list][refn];

  3016.         mc_dir_part(h, ref, n, square, chroma_height, delta, list,

  3017.                     dest_y, dest_cb, dest_cr, x_offset, y_offset,

  3018.                     qpix_put, chroma_put);

  3019. 

  3020.         luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom,

  3021.                        h->luma_weight[list][refn], h->luma_offset[list][refn]);

  3022.         if(h->use_weight_chroma){

  3023.             chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,

  3024.                              h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]);

  3025.             chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,

  3026.                              h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]);

  3027.         }

  3028.     }

  3029. }

  3030. 

  3031. static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta,

  3032.                            uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

  3033.                            int x_offset, int y_offset,

  3034.                            qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,

  3035.                            qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,

  3036.                            h264_weight_func *weight_op, h264_biweight_func *weight_avg,

  3037.                            int list0, int list1){

  3038.     if((h->use_weight==2 && list0 && list1

  3039.         && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32))

  3040.        || h->use_weight==1)

  3041.         mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,

  3042.                          x_offset, y_offset, qpix_put, chroma_put,

  3043.                          weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1);

  3044.     else

  3045.         mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,

  3046.                     x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1);

  3047. }

  3048. 

  3049. static inline void prefetch_motion(H264Context *h, int list){

  3050.     /* fetch pixels for estimated mv 4 macroblocks ahead

  3051.      * optimized for 64byte cache lines */

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

  3053.     const int refn = h->ref_cache[list][scan8[0]];

  3054.     if(refn >= 0){

  3055.         const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8;

  3056.         const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y;

  3057.         uint8_t **src= h->ref_list[list][refn].data;

  3058.         int off= mx + (my + (s->mb_x&3)*4)*h->mb_linesize + 64;

  3059.         s->dsp.prefetch(src[0]+off, s->linesize, 4);

  3060.         off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;

  3061.         s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);

  3062.     }

  3063. }

  3064. 

  3065. static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

  3066.                       qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),

  3067.                       qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),

  3068.                       h264_weight_func *weight_op, h264_biweight_func *weight_avg){

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

  3070.     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;

  3071.     const int mb_type= s->current_picture.mb_type[mb_xy];

  3072. 

  3073.     assert(IS_INTER(mb_type));

  3074. 

  3075.     prefetch_motion(h, 0);

  3076. 

  3077.     if(IS_16X16(mb_type)){

  3078.         mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,

  3079.                 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],

  3080.                 &weight_op[0], &weight_avg[0],

  3081.                 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));

  3082.     }else if(IS_16X8(mb_type)){

  3083.         mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0,

  3084.                 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],

  3085.                 &weight_op[1], &weight_avg[1],

  3086.                 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));

  3087.         mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4,

  3088.                 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],

  3089.                 &weight_op[1], &weight_avg[1],

  3090.                 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));

  3091.     }else if(IS_8X16(mb_type)){

  3092.         mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,

  3093.                 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],

  3094.                 &weight_op[2], &weight_avg[2],

  3095.                 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));

  3096.         mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,

  3097.                 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],

  3098.                 &weight_op[2], &weight_avg[2],

  3099.                 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));

  3100.     }else{

  3101.         int i;

  3102. 

  3103.         assert(IS_8X8(mb_type));

  3104. 

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

  3106.             const int sub_mb_type= h->sub_mb_type[i];

  3107.             const int n= 4*i;

  3108.             int x_offset= (i&1)<<2;

  3109.             int y_offset= (i&2)<<1;

  3110. 

  3111.             if(IS_SUB_8X8(sub_mb_type)){

  3112.                 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,

  3113.                     qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],

  3114.                     &weight_op[3], &weight_avg[3],

  3115.                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));

  3116.             }else if(IS_SUB_8X4(sub_mb_type)){

  3117.                 mc_part(h, n  , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset,

  3118.                     qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],

  3119.                     &weight_op[4], &weight_avg[4],

  3120.                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));

  3121.                 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,

  3122.                     qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],

  3123.                     &weight_op[4], &weight_avg[4],

  3124.                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));

  3125.             }else if(IS_SUB_4X8(sub_mb_type)){

  3126.                 mc_part(h, n  , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,

  3127.                     qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],

  3128.                     &weight_op[5], &weight_avg[5],

  3129.                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));

  3130.                 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,

  3131.                     qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],

  3132.                     &weight_op[5], &weight_avg[5],

  3133.                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));

  3134.             }else{

  3135.                 int j;

  3136.                 assert(IS_SUB_4X4(sub_mb_type));

  3137.                 for(j=0; j<4; j++){

  3138.                     int sub_x_offset= x_offset + 2*(j&1);

  3139.                     int sub_y_offset= y_offset +   (j&2);

  3140.                     mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,

  3141.                         qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],

  3142.                         &weight_op[6], &weight_avg[6],

  3143.                         IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));

  3144.                 }

  3145.             }

  3146.         }

  3147.     }

  3148. 

  3149.     prefetch_motion(h, 1);

  3150. }

  3151. 

  3152. static void decode_init_vlc(){

  3153.     static int done = 0;

  3154. 

  3155.     if (!done) {

  3156.         int i;

  3157.         done = 1;

  3158. 

  3159.         init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,

  3160.                  &chroma_dc_coeff_token_len [0], 1, 1,

  3161.                  &chroma_dc_coeff_token_bits[0], 1, 1, 1);

  3162. 

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

  3164.             init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,

  3165.                      &coeff_token_len [i][0], 1, 1,

  3166.                      &coeff_token_bits[i][0], 1, 1, 1);

  3167.         }

  3168. 

  3169.         for(i=0; i<3; i++){

  3170.             init_vlc(&chroma_dc_total_zeros_vlc[i], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,

  3171.                      &chroma_dc_total_zeros_len [i][0], 1, 1,

  3172.                      &chroma_dc_total_zeros_bits[i][0], 1, 1, 1);

  3173.         }

  3174.         for(i=0; i<15; i++){

  3175.             init_vlc(&total_zeros_vlc[i], TOTAL_ZEROS_VLC_BITS, 16,

  3176.                      &total_zeros_len [i][0], 1, 1,

  3177.                      &total_zeros_bits[i][0], 1, 1, 1);

  3178.         }

  3179. 

  3180.         for(i=0; i<6; i++){

  3181.             init_vlc(&run_vlc[i], RUN_VLC_BITS, 7,

  3182.                      &run_len [i][0], 1, 1,

  3183.                      &run_bits[i][0], 1, 1, 1);

  3184.         }

  3185.         init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,

  3186.                  &run_len [6][0], 1, 1,

  3187.                  &run_bits[6][0], 1, 1, 1);

  3188.     }

  3189. }

  3190. 

  3191. /**

  3192.  * Sets the intra prediction function pointers.

  3193.  */

  3194. static void init_pred_ptrs(H264Context *h){

  3195. //    MpegEncContext * const s = &h->s;

  3196. 

  3197.     h->pred4x4[VERT_PRED           ]= pred4x4_vertical_c;

  3198.     h->pred4x4[HOR_PRED            ]= pred4x4_horizontal_c;

  3199.     h->pred4x4[DC_PRED             ]= pred4x4_dc_c;

  3200.     h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_c;

  3201.     h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c;

  3202.     h->pred4x4[VERT_RIGHT_PRED     ]= pred4x4_vertical_right_c;

  3203.     h->pred4x4[HOR_DOWN_PRED       ]= pred4x4_horizontal_down_c;

  3204.     h->pred4x4[VERT_LEFT_PRED      ]= pred4x4_vertical_left_c;

  3205.     h->pred4x4[HOR_UP_PRED         ]= pred4x4_horizontal_up_c;

  3206.     h->pred4x4[LEFT_DC_PRED        ]= pred4x4_left_dc_c;

  3207.     h->pred4x4[TOP_DC_PRED         ]= pred4x4_top_dc_c;

  3208.     h->pred4x4[DC_128_PRED         ]= pred4x4_128_dc_c;

  3209. 

  3210.     h->pred8x8l[VERT_PRED           ]= pred8x8l_vertical_c;

  3211.     h->pred8x8l[HOR_PRED            ]= pred8x8l_horizontal_c;

  3212.     h->pred8x8l[DC_PRED             ]= pred8x8l_dc_c;

  3213.     h->pred8x8l[DIAG_DOWN_LEFT_PRED ]= pred8x8l_down_left_c;

  3214.     h->pred8x8l[DIAG_DOWN_RIGHT_PRED]= pred8x8l_down_right_c;

  3215.     h->pred8x8l[VERT_RIGHT_PRED     ]= pred8x8l_vertical_right_c;

  3216.     h->pred8x8l[HOR_DOWN_PRED       ]= pred8x8l_horizontal_down_c;

  3217.     h->pred8x8l[VERT_LEFT_PRED      ]= pred8x8l_vertical_left_c;

  3218.     h->pred8x8l[HOR_UP_PRED         ]= pred8x8l_horizontal_up_c;

  3219.     h->pred8x8l[LEFT_DC_PRED        ]= pred8x8l_left_dc_c;

  3220.     h->pred8x8l[TOP_DC_PRED         ]= pred8x8l_top_dc_c;

  3221.     h->pred8x8l[DC_128_PRED         ]= pred8x8l_128_dc_c;

  3222. 

  3223.     h->pred8x8[DC_PRED8x8     ]= pred8x8_dc_c;

  3224.     h->pred8x8[VERT_PRED8x8   ]= pred8x8_vertical_c;

  3225.     h->pred8x8[HOR_PRED8x8    ]= pred8x8_horizontal_c;

  3226.     h->pred8x8[PLANE_PRED8x8  ]= pred8x8_plane_c;

  3227.     h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_c;

  3228.     h->pred8x8[TOP_DC_PRED8x8 ]= pred8x8_top_dc_c;

  3229.     h->pred8x8[DC_128_PRED8x8 ]= pred8x8_128_dc_c;

  3230. 

  3231.     h->pred16x16[DC_PRED8x8     ]= pred16x16_dc_c;

  3232.     h->pred16x16[VERT_PRED8x8   ]= pred16x16_vertical_c;

  3233.     h->pred16x16[HOR_PRED8x8    ]= pred16x16_horizontal_c;

  3234.     h->pred16x16[PLANE_PRED8x8  ]= pred16x16_plane_c;

  3235.     h->pred16x16[LEFT_DC_PRED8x8]= pred16x16_left_dc_c;

  3236.     h->pred16x16[TOP_DC_PRED8x8 ]= pred16x16_top_dc_c;

  3237.     h->pred16x16[DC_128_PRED8x8 ]= pred16x16_128_dc_c;

  3238. }

  3239. 

  3240. static void free_tables(H264Context *h){

  3241.     av_freep(&h->intra4x4_pred_mode);

  3242.     av_freep(&h->chroma_pred_mode_table);

  3243.     av_freep(&h->cbp_table);

  3244.     av_freep(&h->mvd_table[0]);

  3245.     av_freep(&h->mvd_table[1]);

  3246.     av_freep(&h->direct_table);

  3247.     av_freep(&h->non_zero_count);

  3248.     av_freep(&h->slice_table_base);

  3249.     av_freep(&h->top_borders[1]);

  3250.     av_freep(&h->top_borders[0]);

  3251.     h->slice_table= NULL;

  3252. 

  3253.     av_freep(&h->mb2b_xy);

  3254.     av_freep(&h->mb2b8_xy);

  3255. 

  3256.     av_freep(&h->s.obmc_scratchpad);

  3257. }

  3258. 

  3259. static void init_dequant8_coeff_table(H264Context *h){

  3260.     int i,q,x;

  3261.     const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly

  3262.     h->dequant8_coeff[0] = h->dequant8_buffer[0];

  3263.     h->dequant8_coeff[1] = h->dequant8_buffer[1];

  3264. 

  3265.     for(i=0; i<2; i++ ){

  3266.         if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){

  3267.             h->dequant8_coeff[1] = h->dequant8_buffer[0];

  3268.             break;

  3269.         }

  3270. 

  3271.         for(q=0; q<52; q++){

  3272.             int shift = div6[q];

  3273.             int idx = rem6[q];

  3274.             for(x=0; x<64; x++)

  3275.                 h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] =

  3276.                     ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] *

  3277.                     h->pps.scaling_matrix8[i][x]) << shift;

  3278.         }

  3279.     }

  3280. }

  3281. 

  3282. static void init_dequant4_coeff_table(H264Context *h){

  3283.     int i,j,q,x;

  3284.     const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly

  3285.     for(i=0; i<6; i++ ){

  3286.         h->dequant4_coeff[i] = h->dequant4_buffer[i];

  3287.         for(j=0; j<i; j++){

  3288.             if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){

  3289.                 h->dequant4_coeff[i] = h->dequant4_buffer[j];

  3290.                 break;

  3291.             }

  3292.         }

  3293.         if(j<i)

  3294.             continue;

  3295. 

  3296.         for(q=0; q<52; q++){

  3297.             int shift = div6[q] + 2;

  3298.             int idx = rem6[q];

  3299.             for(x=0; x<16; x++)

  3300.                 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] =

  3301.                     ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] *

  3302.                     h->pps.scaling_matrix4[i][x]) << shift;

  3303.         }

  3304.     }

  3305. }

  3306. 

  3307. static void init_dequant_tables(H264Context *h){

  3308.     int i,x;

  3309.     init_dequant4_coeff_table(h);

  3310.     if(h->pps.transform_8x8_mode)

  3311.         init_dequant8_coeff_table(h);

  3312.     if(h->sps.transform_bypass){

  3313.         for(i=0; i<6; i++)

  3314.             for(x=0; x<16; x++)

  3315.                 h->dequant4_coeff[i][0][x] = 1<<6;

  3316.         if(h->pps.transform_8x8_mode)

  3317.             for(i=0; i<2; i++)

  3318.                 for(x=0; x<64; x++)

  3319.                     h->dequant8_coeff[i][0][x] = 1<<6;

  3320.     }

  3321. }

  3322. 

  3323. 

  3324. /**

  3325.  * allocates tables.

  3326.  * needs width/height

  3327.  */

  3328. static int alloc_tables(H264Context *h){

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

  3330.     const int big_mb_num= s->mb_stride * (s->mb_height+1);

  3331.     int x,y;

  3332. 

  3333.     CHECKED_ALLOCZ(h->intra4x4_pred_mode, big_mb_num * 8  * sizeof(uint8_t))

  3334. 

  3335.     CHECKED_ALLOCZ(h->non_zero_count    , big_mb_num * 16 * sizeof(uint8_t))

  3336.     CHECKED_ALLOCZ(h->slice_table_base  , (big_mb_num+s->mb_stride) * sizeof(uint8_t))

  3337.     CHECKED_ALLOCZ(h->top_borders[0]    , s->mb_width * (16+8+8) * sizeof(uint8_t))

  3338.     CHECKED_ALLOCZ(h->top_borders[1]    , s->mb_width * (16+8+8) * sizeof(uint8_t))

  3339.     CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t))

  3340. 

  3341.     if( h->pps.cabac ) {

  3342.         CHECKED_ALLOCZ(h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t))

  3343.         CHECKED_ALLOCZ(h->mvd_table[0], 32*big_mb_num * sizeof(uint16_t));

  3344.         CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t));

  3345.         CHECKED_ALLOCZ(h->direct_table, 32*big_mb_num * sizeof(uint8_t));

  3346.     }

  3347. 

  3348.     memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride)  * sizeof(uint8_t));

  3349.     h->slice_table= h->slice_table_base + s->mb_stride*2 + 1;

  3350. 

  3351.     CHECKED_ALLOCZ(h->mb2b_xy  , big_mb_num * sizeof(uint32_t));

  3352.     CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t));

  3353.     for(y=0; y<s->mb_height; y++){

  3354.         for(x=0; x<s->mb_width; x++){

  3355.             const int mb_xy= x + y*s->mb_stride;

  3356.             const int b_xy = 4*x + 4*y*h->b_stride;

  3357.             const int b8_xy= 2*x + 2*y*h->b8_stride;

  3358. 

  3359.             h->mb2b_xy [mb_xy]= b_xy;

  3360.             h->mb2b8_xy[mb_xy]= b8_xy;

  3361.         }

  3362.     }

  3363. 

  3364.     s->obmc_scratchpad = NULL;

  3365. 

  3366.     if(!h->dequant4_coeff[0])

  3367.         init_dequant_tables(h);

  3368. 

  3369.     return 0;

  3370. fail:

  3371.     free_tables(h);

  3372.     return -1;

  3373. }

  3374. 

  3375. static void common_init(H264Context *h){

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

  3377. 

  3378.     s->width = s->avctx->width;

  3379.     s->height = s->avctx->height;

  3380.     s->codec_id= s->avctx->codec->id;

  3381. 

  3382.     init_pred_ptrs(h);

  3383. 

  3384.     h->dequant_coeff_pps= -1;

  3385.     s->unrestricted_mv=1;

  3386.     s->decode=1; //FIXME

  3387. 

  3388.     memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));

  3389.     memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));

  3390. }

  3391. 

  3392. static int decode_init(AVCodecContext *avctx){

  3393.     H264Context *h= avctx->priv_data;

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

  3395. 

  3396.     MPV_decode_defaults(s);

  3397. 

  3398.     s->avctx = avctx;

  3399.     common_init(h);

  3400. 

  3401.     s->out_format = FMT_H264;

  3402.     s->workaround_bugs= avctx->workaround_bugs;

  3403. 

  3404.     // set defaults

  3405. //    s->decode_mb= ff_h263_decode_mb;

  3406.     s->low_delay= 1;

  3407.     avctx->pix_fmt= PIX_FMT_YUV420P;

  3408. 

  3409.     decode_init_vlc();

  3410. 

  3411.     if(avctx->extradata_size > 0 && avctx->extradata &&

  3412.        *(char *)avctx->extradata == 1){

  3413.         h->is_avc = 1;

  3414.         h->got_avcC = 0;

  3415.     } else {

  3416.         h->is_avc = 0;

  3417.     }

  3418. 

  3419.     return 0;

  3420. }

  3421. 

  3422. static int frame_start(H264Context *h){

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

  3424.     int i;

  3425. 

  3426.     if(MPV_frame_start(s, s->avctx) < 0)

  3427.         return -1;

  3428.     ff_er_frame_start(s);

  3429. 

  3430.     assert(s->linesize && s->uvlinesize);

  3431. 

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

  3433.         h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3);

  3434.         h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3);

  3435.     }

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

  3437.         h->block_offset[16+i]=

  3438.         h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);

  3439.         h->block_offset[24+16+i]=

  3440.         h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3);

  3441.     }

  3442. 

  3443.     /* can't be in alloc_tables because linesize isn't known there.

  3444.      * FIXME: redo bipred weight to not require extra buffer? */

  3445.     if(!s->obmc_scratchpad)

  3446.         s->obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);

  3447. 

  3448.     /* some macroblocks will be accessed before they're available */

  3449.     if(FRAME_MBAFF)

  3450.         memset(h->slice_table, -1, (s->mb_height*s->mb_stride-1) * sizeof(uint8_t));

  3451. 

  3452. //    s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;

  3453.     return 0;

  3454. }

  3455. 

  3456. static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){

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

  3458.     int i;

  3459. 

  3460.     src_y  -=   linesize;

  3461.     src_cb -= uvlinesize;

  3462.     src_cr -= uvlinesize;

  3463. 

  3464.     // There are two lines saved, the line above the the top macroblock of a pair,

  3465.     // and the line above the bottom macroblock

  3466.     h->left_border[0]= h->top_borders[0][s->mb_x][15];

  3467.     for(i=1; i<17; i++){

  3468.         h->left_border[i]= src_y[15+i*  linesize];

  3469.     }

  3470. 

  3471.     *(uint64_t*)(h->top_borders[0][s->mb_x]+0)= *(uint64_t*)(src_y +  16*linesize);

  3472.     *(uint64_t*)(h->top_borders[0][s->mb_x]+8)= *(uint64_t*)(src_y +8+16*linesize);

  3473. 

  3474.     if(!(s->flags&CODEC_FLAG_GRAY)){

  3475.         h->left_border[17  ]= h->top_borders[0][s->mb_x][16+7];

  3476.         h->left_border[17+9]= h->top_borders[0][s->mb_x][24+7];

  3477.         for(i=1; i<9; i++){

  3478.             h->left_border[i+17  ]= src_cb[7+i*uvlinesize];

  3479.             h->left_border[i+17+9]= src_cr[7+i*uvlinesize];

  3480.         }

  3481.         *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+8*uvlinesize);

  3482.         *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+8*uvlinesize);

  3483.     }

  3484. }

  3485. 

  3486. static inline void xchg_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int xchg){

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

  3488.     int temp8, i;

  3489.     uint64_t temp64;

  3490.     int deblock_left = (s->mb_x > 0);

  3491.     int deblock_top  = (s->mb_y > 0);

  3492. 

  3493.     src_y  -=   linesize + 1;

  3494.     src_cb -= uvlinesize + 1;

  3495.     src_cr -= uvlinesize + 1;

  3496. 

  3497. #define XCHG(a,b,t,xchg)\

  3498. t= a;\

  3499. if(xchg)\

  3500.     a= b;\

  3501. b= t;

  3502. 

  3503.     if(deblock_left){

  3504.         for(i = !deblock_top; i<17; i++){

  3505.             XCHG(h->left_border[i     ], src_y [i*  linesize], temp8, xchg);

  3506.         }

  3507.     }

  3508. 

  3509.     if(deblock_top){

  3510.         XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg);

  3511.         XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1);

  3512.         if(s->mb_x+1 < s->mb_width){

  3513.             XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1);

  3514.         }

  3515.     }

  3516. 

  3517.     if(!(s->flags&CODEC_FLAG_GRAY)){

  3518.         if(deblock_left){

  3519.             for(i = !deblock_top; i<9; i++){

  3520.                 XCHG(h->left_border[i+17  ], src_cb[i*uvlinesize], temp8, xchg);

  3521.                 XCHG(h->left_border[i+17+9], src_cr[i*uvlinesize], temp8, xchg);

  3522.             }

  3523.         }

  3524.         if(deblock_top){

  3525.             XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1);

  3526.             XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1);

  3527.         }

  3528.     }

  3529. }

  3530. 

  3531. static inline void backup_pair_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){

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

  3533.     int i;

  3534. 

  3535.     src_y  -= 2 *   linesize;

  3536.     src_cb -= 2 * uvlinesize;

  3537.     src_cr -= 2 * uvlinesize;

  3538. 

  3539.     // There are two lines saved, the line above the the top macroblock of a pair,

  3540.     // and the line above the bottom macroblock

  3541.     h->left_border[0]= h->top_borders[0][s->mb_x][15];

  3542.     h->left_border[1]= h->top_borders[1][s->mb_x][15];

  3543.     for(i=2; i<34; i++){

  3544.         h->left_border[i]= src_y[15+i*  linesize];

  3545.     }

  3546. 

  3547.     *(uint64_t*)(h->top_borders[0][s->mb_x]+0)= *(uint64_t*)(src_y +  32*linesize);

  3548.     *(uint64_t*)(h->top_borders[0][s->mb_x]+8)= *(uint64_t*)(src_y +8+32*linesize);

  3549.     *(uint64_t*)(h->top_borders[1][s->mb_x]+0)= *(uint64_t*)(src_y +  33*linesize);

  3550.     *(uint64_t*)(h->top_borders[1][s->mb_x]+8)= *(uint64_t*)(src_y +8+33*linesize);

  3551. 

  3552.     if(!(s->flags&CODEC_FLAG_GRAY)){

  3553.         h->left_border[34     ]= h->top_borders[0][s->mb_x][16+7];

  3554.         h->left_border[34+   1]= h->top_borders[1][s->mb_x][16+7];

  3555.         h->left_border[34+18  ]= h->top_borders[0][s->mb_x][24+7];

  3556.         h->left_border[34+18+1]= h->top_borders[1][s->mb_x][24+7];

  3557.         for(i=2; i<18; i++){

  3558.             h->left_border[i+34   ]= src_cb[7+i*uvlinesize];

  3559.             h->left_border[i+34+18]= src_cr[7+i*uvlinesize];

  3560.         }

  3561.         *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+16*uvlinesize);

  3562.         *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+16*uvlinesize);

  3563.         *(uint64_t*)(h->top_borders[1][s->mb_x]+16)= *(uint64_t*)(src_cb+17*uvlinesize);

  3564.         *(uint64_t*)(h->top_borders[1][s->mb_x]+24)= *(uint64_t*)(src_cr+17*uvlinesize);

  3565.     }

  3566. }

  3567. 

  3568. static inline void xchg_pair_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int xchg){

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

  3570.     int temp8, i;

  3571.     uint64_t temp64;

  3572.     int deblock_left = (s->mb_x > 0);

  3573.     int deblock_top  = (s->mb_y > 1);

  3574. 

  3575.     tprintf("xchg_pair_border: src_y:%p src_cb:%p src_cr:%p ls:%d uvls:%d\n", src_y, src_cb, src_cr, linesize, uvlinesize);

  3576. 

  3577.     src_y  -= 2 *   linesize + 1;

  3578.     src_cb -= 2 * uvlinesize + 1;

  3579.     src_cr -= 2 * uvlinesize + 1;

  3580. 

  3581. #define XCHG(a,b,t,xchg)\

  3582. t= a;\

  3583. if(xchg)\

  3584.     a= b;\

  3585. b= t;

  3586. 

  3587.     if(deblock_left){

  3588.         for(i = (!deblock_top)<<1; i<34; i++){

  3589.             XCHG(h->left_border[i     ], src_y [i*  linesize], temp8, xchg);

  3590.         }

  3591.     }

  3592. 

  3593.     if(deblock_top){

  3594.         XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg);

  3595.         XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1);

  3596.         XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+0), *(uint64_t*)(src_y +1 +linesize), temp64, xchg);

  3597.         XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+8), *(uint64_t*)(src_y +9 +linesize), temp64, 1);

  3598.         if(s->mb_x+1 < s->mb_width){

  3599.             XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1);

  3600.             XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x+1]), *(uint64_t*)(src_y +17 +linesize), temp64, 1);

  3601.         }

  3602.     }

  3603. 

  3604.     if(!(s->flags&CODEC_FLAG_GRAY)){

  3605.         if(deblock_left){

  3606.             for(i = (!deblock_top) << 1; i<18; i++){

  3607.                 XCHG(h->left_border[i+34   ], src_cb[i*uvlinesize], temp8, xchg);

  3608.                 XCHG(h->left_border[i+34+18], src_cr[i*uvlinesize], temp8, xchg);

  3609.             }

  3610.         }

  3611.         if(deblock_top){

  3612.             XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1);

  3613.             XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1);

  3614.             XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+16), *(uint64_t*)(src_cb+1 +uvlinesize), temp64, 1);

  3615.             XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+24), *(uint64_t*)(src_cr+1 +uvlinesize), temp64, 1);

  3616.         }

  3617.     }

  3618. }

  3619. 

  3620. static void hl_decode_mb(H264Context *h){

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

  3622.     const int mb_x= s->mb_x;

  3623.     const int mb_y= s->mb_y;

  3624.     const int mb_xy= mb_x + mb_y*s->mb_stride;

  3625.     const int mb_type= s->current_picture.mb_type[mb_xy];

  3626.     uint8_t  *dest_y, *dest_cb, *dest_cr;

  3627.     int linesize, uvlinesize /*dct_offset*/;

  3628.     int i;

  3629.     int *block_offset = &h->block_offset[0];

  3630.     const unsigned int bottom = mb_y & 1;

  3631.     const int transform_bypass = (s->qscale == 0 && h->sps.transform_bypass);

  3632.     void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);

  3633.     void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);

  3634. 

  3635.     if(!s->decode)

  3636.         return;

  3637. 

  3638.     dest_y  = s->current_picture.data[0] + (mb_y * 16* s->linesize  ) + mb_x * 16;

  3639.     dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;

  3640.     dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;

  3641. 

  3642.     s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4);

  3643.     s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2);

  3644. 

  3645.     if (MB_FIELD) {

  3646.         linesize   = h->mb_linesize   = s->linesize * 2;

  3647.         uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;

  3648.         block_offset = &h->block_offset[24];

  3649.         if(mb_y&1){ //FIXME move out of this func?

  3650.             dest_y -= s->linesize*15;

  3651.             dest_cb-= s->uvlinesize*7;

  3652.             dest_cr-= s->uvlinesize*7;

  3653.         }

  3654.         if(FRAME_MBAFF) {

  3655.             int list;

  3656.             for(list=0; list<2; list++){

  3657.                 if(!USES_LIST(mb_type, list))

  3658.                     continue;

  3659.                 if(IS_16X16(mb_type)){

  3660.                     int8_t *ref = &h->ref_cache[list][scan8[0]];

  3661.                     fill_rectangle(ref, 4, 4, 8, 16+*ref^(s->mb_y&1), 1);

  3662.                 }else{

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

  3664.                         //FIXME can refs be smaller than 8x8 when !direct_8x8_inference ?

  3665.                         int ref = h->ref_cache[list][scan8[i]];

  3666.                         if(ref >= 0)

  3667.                             fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, 16+ref^(s->mb_y&1), 1);

  3668.                     }

  3669.                 }

  3670.             }

  3671.         }

  3672.     } else {

  3673.         linesize   = h->mb_linesize   = s->linesize;

  3674.         uvlinesize = h->mb_uvlinesize = s->uvlinesize;

  3675. //        dct_offset = s->linesize * 16;

  3676.     }

  3677. 

  3678.     if(transform_bypass){

  3679.         idct_dc_add =

  3680.         idct_add = IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4;

  3681.     }else if(IS_8x8DCT(mb_type)){

  3682.         idct_dc_add = s->dsp.h264_idct8_dc_add;

  3683.         idct_add = s->dsp.h264_idct8_add;

  3684.     }else{

  3685.         idct_dc_add = s->dsp.h264_idct_dc_add;

  3686.         idct_add = s->dsp.h264_idct_add;

  3687.     }

  3688. 

  3689.     if(FRAME_MBAFF && h->deblocking_filter && IS_INTRA(mb_type)

  3690.        && (!bottom || !IS_INTRA(s->current_picture.mb_type[mb_xy-s->mb_stride]))){

  3691.         int mbt_y = mb_y&~1;

  3692.         uint8_t *top_y  = s->current_picture.data[0] + (mbt_y * 16* s->linesize  ) + mb_x * 16;

  3693.         uint8_t *top_cb = s->current_picture.data[1] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8;

  3694.         uint8_t *top_cr = s->current_picture.data[2] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8;

  3695.         xchg_pair_border(h, top_y, top_cb, top_cr, s->linesize, s->uvlinesize, 1);

  3696.     }

  3697. 

  3698.     if (IS_INTRA_PCM(mb_type)) {

  3699.         unsigned int x, y;

  3700. 

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

  3702.         // copy them in output in the correct order.

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

  3704.             for (y=0; y<4; y++) {

  3705.                 for (x=0; x<4; x++) {

  3706.                     *(dest_y + block_offset[i] + y*linesize + x) = h->mb[i*16+y*4+x];

  3707.                 }

  3708.             }

  3709.         }

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

  3711.             for (y=0; y<4; y++) {

  3712.                 for (x=0; x<4; x++) {

  3713.                     *(dest_cb + block_offset[i] + y*uvlinesize + x) = h->mb[i*16+y*4+x];

  3714.                 }

  3715.             }

  3716.         }

  3717.         for(i=20; i<20+4; i++) {

  3718.             for (y=0; y<4; y++) {

  3719.                 for (x=0; x<4; x++) {

  3720.                     *(dest_cr + block_offset[i] + y*uvlinesize + x) = h->mb[i*16+y*4+x];

  3721.                 }

  3722.             }

  3723.         }

  3724.     } else {

  3725.         if(IS_INTRA(mb_type)){

  3726.             if(h->deblocking_filter && !FRAME_MBAFF)

  3727.                 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1);

  3728. 

  3729.             if(!(s->flags&CODEC_FLAG_GRAY)){

  3730.                 h->pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);

  3731.                 h->pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);

  3732.             }

  3733. 

  3734.             if(IS_INTRA4x4(mb_type)){

  3735.                 if(!s->encoding){

  3736.                     if(IS_8x8DCT(mb_type)){

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

  3738.                             uint8_t * const ptr= dest_y + block_offset[i];

  3739.                             const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];

  3740.                             const int nnz = h->non_zero_count_cache[ scan8[i] ];

  3741.                             h->pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,

  3742.                                                    (h->topright_samples_available<<(i+1))&0x8000, linesize);

  3743.                             if(nnz){

  3744.                                 if(nnz == 1 && h->mb[i*16])

  3745.                                     idct_dc_add(ptr, h->mb + i*16, linesize);

  3746.                                 else

  3747.                                     idct_add(ptr, h->mb + i*16, linesize);

  3748.                             }

  3749.                         }

  3750.                     }else

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

  3752.                         uint8_t * const ptr= dest_y + block_offset[i];

  3753.                         uint8_t *topright;

  3754.                         const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];

  3755.                         int nnz, tr;

  3756. 

  3757.                         if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){

  3758.                             const int topright_avail= (h->topright_samples_available<<i)&0x8000;

  3759.                             assert(mb_y || linesize <= block_offset[i]);

  3760.                             if(!topright_avail){

  3761.                                 tr= ptr[3 - linesize]*0x01010101;

  3762.                                 topright= (uint8_t*) &tr;

  3763.                             }else

  3764.                                 topright= ptr + 4 - linesize;

  3765.                         }else

  3766.                             topright= NULL;

  3767. 

  3768.                         h->pred4x4[ dir ](ptr, topright, linesize);

  3769.                         nnz = h->non_zero_count_cache[ scan8[i] ];

  3770.                         if(nnz){

  3771.                             if(s->codec_id == CODEC_ID_H264){

  3772.                                 if(nnz == 1 && h->mb[i*16])

  3773.                                     idct_dc_add(ptr, h->mb + i*16, linesize);

  3774.                                 else

  3775.                                     idct_add(ptr, h->mb + i*16, linesize);

  3776.                             }else

  3777.                                 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);

  3778.                         }

  3779.                     }

  3780.                 }

  3781.             }else{

  3782.                 h->pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);

  3783.                 if(s->codec_id == CODEC_ID_H264){

  3784.                     if(!transform_bypass)

  3785.                         h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[IS_INTRA(mb_type) ? 0:3][s->qscale][0]);

  3786.                 }else

  3787.                     svq3_luma_dc_dequant_idct_c(h->mb, s->qscale);

  3788.             }

  3789.             if(h->deblocking_filter && !FRAME_MBAFF)

  3790.                 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0);

  3791.         }else if(s->codec_id == CODEC_ID_H264){

  3792.             hl_motion(h, dest_y, dest_cb, dest_cr,

  3793.                       s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,

  3794.                       s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,

  3795.                       s->dsp.weight_h264_pixels_tab, s->dsp.biweight_h264_pixels_tab);

  3796.         }

  3797. 

  3798. 

  3799.         if(!IS_INTRA4x4(mb_type)){

  3800.             if(s->codec_id == CODEC_ID_H264){

  3801.                 if(IS_INTRA16x16(mb_type)){

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

  3803.                         if(h->non_zero_count_cache[ scan8[i] ])

  3804.                             idct_add(dest_y + block_offset[i], h->mb + i*16, linesize);

  3805.                         else if(h->mb[i*16])

  3806.                             idct_dc_add(dest_y + block_offset[i], h->mb + i*16, linesize);

  3807.                     }

  3808.                 }else{

  3809.                     const int di = IS_8x8DCT(mb_type) ? 4 : 1;

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

  3811.                         int nnz = h->non_zero_count_cache[ scan8[i] ];

  3812.                         if(nnz){

  3813.                             if(nnz==1 && h->mb[i*16])

  3814.                                 idct_dc_add(dest_y + block_offset[i], h->mb + i*16, linesize);

  3815.                             else

  3816.                                 idct_add(dest_y + block_offset[i], h->mb + i*16, linesize);

  3817.                         }

  3818.                     }

  3819.                 }

  3820.             }else{

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

  3822.                     if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below

  3823.                         uint8_t * const ptr= dest_y + block_offset[i];

  3824.                         svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0);

  3825.                     }

  3826.                 }

  3827.             }

  3828.         }

  3829. 

  3830.         if(!(s->flags&CODEC_FLAG_GRAY)){

  3831.             uint8_t *dest[2] = {dest_cb, dest_cr};

  3832.             if(transform_bypass){

  3833.                 idct_add = idct_dc_add = s->dsp.add_pixels4;

  3834.             }else{

  3835.                 idct_add = s->dsp.h264_idct_add;

  3836.                 idct_dc_add = s->dsp.h264_idct_dc_add;

  3837.                 chroma_dc_dequant_idct_c(h->mb + 16*16, h->chroma_qp, h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp][0]);

  3838.                 chroma_dc_dequant_idct_c(h->mb + 16*16+4*16, h->chroma_qp, h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp][0]);

  3839.             }

  3840.             if(s->codec_id == CODEC_ID_H264){

  3841.                 for(i=16; i<16+8; i++){

  3842.                     if(h->non_zero_count_cache[ scan8[i] ])

  3843.                         idct_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);

  3844.                     else if(h->mb[i*16])

  3845.                         idct_dc_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);

  3846.                 }

  3847.             }else{

  3848.                 for(i=16; i<16+8; i++){

  3849.                     if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){

  3850.                         uint8_t * const ptr= dest[(i&4)>>2] + block_offset[i];

  3851.                         svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2);

  3852.                     }

  3853.                 }

  3854.             }

  3855.         }

  3856.     }

  3857.     if(h->deblocking_filter) {

  3858.         if (FRAME_MBAFF) {

  3859.             //FIXME try deblocking one mb at a time?

  3860.             // the reduction in load/storing mvs and such might outweigh the extra backup/xchg_border

  3861.             const int mb_y = s->mb_y - 1;

  3862.             uint8_t  *pair_dest_y, *pair_dest_cb, *pair_dest_cr;

  3863.             const int mb_xy= mb_x + mb_y*s->mb_stride;

  3864.             const int mb_type_top   = s->current_picture.mb_type[mb_xy];

  3865.             const int mb_type_bottom= s->current_picture.mb_type[mb_xy+s->mb_stride];

  3866.             if (!bottom) return;

  3867.             pair_dest_y  = s->current_picture.data[0] + (mb_y * 16* s->linesize  ) + mb_x * 16;

  3868.             pair_dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;

  3869.             pair_dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;

  3870. 

  3871.             if(IS_INTRA(mb_type_top | mb_type_bottom))

  3872.                 xchg_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize, 0);

  3873. 

  3874.             backup_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize);

  3875.             // deblock a pair

  3876.             // top

  3877.             s->mb_y--;

  3878.             tprintf("call mbaff filter_mb mb_x:%d mb_y:%d pair_dest_y = %p, dest_y = %p\n", mb_x, mb_y, pair_dest_y, dest_y);

  3879.             fill_caches(h, mb_type_top, 1); //FIXME don't fill stuff which isn't used by filter_mb

  3880.             h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mb_xy]);

  3881.             filter_mb(h, mb_x, mb_y, pair_dest_y, pair_dest_cb, pair_dest_cr, linesize, uvlinesize);

  3882.             // bottom

  3883.             s->mb_y++;

  3884.             tprintf("call mbaff filter_mb\n");

  3885.             fill_caches(h, mb_type_bottom, 1); //FIXME don't fill stuff which isn't used by filter_mb

  3886.             h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mb_xy+s->mb_stride]);

  3887.             filter_mb(h, mb_x, mb_y+1, dest_y, dest_cb, dest_cr, linesize, uvlinesize);

  3888.         } else {

  3889.             tprintf("call filter_mb\n");

  3890.             backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize);

  3891.             fill_caches(h, mb_type, 1); //FIXME don't fill stuff which isn't used by filter_mb

  3892.             filter_mb_fast(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);

  3893.         }

  3894.     }

  3895. }

  3896. 

  3897. /**

  3898.  * fills the default_ref_list.

  3899.  */

  3900. static int fill_default_ref_list(H264Context *h){

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

  3902.     int i;

  3903.     int smallest_poc_greater_than_current = -1;

  3904.     Picture sorted_short_ref[32];

  3905. 

  3906.     if(h->slice_type==B_TYPE){

  3907.         int out_i;

  3908.         int limit= INT_MIN;

  3909. 

  3910.         /* sort frame according to poc in B slice */

  3911.         for(out_i=0; out_i<h->short_ref_count; out_i++){

  3912.             int best_i=INT_MIN;

  3913.             int best_poc=INT_MAX;

  3914. 

  3915.             for(i=0; i<h->short_ref_count; i++){

  3916.                 const int poc= h->short_ref[i]->poc;

  3917.                 if(poc > limit && poc < best_poc){

  3918.                     best_poc= poc;

  3919.                     best_i= i;

  3920.                 }

  3921.             }

  3922. 

  3923.             assert(best_i != INT_MIN);

  3924. 

  3925.             limit= best_poc;

  3926.             sorted_short_ref[out_i]= *h->short_ref[best_i];

  3927.             tprintf("sorted poc: %d->%d poc:%d fn:%d\n", best_i, out_i, sorted_short_ref[out_i].poc, sorted_short_ref[out_i].frame_num);

  3928.             if (-1 == smallest_poc_greater_than_current) {

  3929.                 if (h->short_ref[best_i]->poc >= s->current_picture_ptr->poc) {

  3930.                     smallest_poc_greater_than_current = out_i;

  3931.                 }

  3932.             }

  3933.         }

  3934.     }

  3935. 

  3936.     if(s->picture_structure == PICT_FRAME){

  3937.         if(h->slice_type==B_TYPE){

  3938.             int list;

  3939.             tprintf("current poc: %d, smallest_poc_greater_than_current: %d\n", s->current_picture_ptr->poc, smallest_poc_greater_than_current);

  3940. 

  3941.             // find the largest poc

  3942.             for(list=0; list<2; list++){

  3943.                 int index = 0;

  3944.                 int j= -99;

  3945.                 int step= list ? -1 : 1;

  3946. 

  3947.                 for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++, j+=step) {

  3948.                     while(j<0 || j>= h->short_ref_count){

  3949.                         if(j != -99 && step == (list ? -1 : 1))

  3950.                             return -1;

  3951.                         step = -step;

  3952.                         j= smallest_poc_greater_than_current + (step>>1);

  3953.                     }

  3954.                     if(sorted_short_ref[j].reference != 3) continue;

  3955.                     h->default_ref_list[list][index  ]= sorted_short_ref[j];

  3956.                     h->default_ref_list[list][index++].pic_id= sorted_short_ref[j].frame_num;

  3957.                 }

  3958. 

  3959.                 for(i = 0; i < 16 && index < h->ref_count[ list ]; i++){

  3960.                     if(h->long_ref[i] == NULL) continue;

  3961.                     if(h->long_ref[i]->reference != 3) continue;

  3962. 

  3963.                     h->default_ref_list[ list ][index  ]= *h->long_ref[i];

  3964.                     h->default_ref_list[ list ][index++].pic_id= i;;

  3965.                 }

  3966. 

  3967.                 if(list && (smallest_poc_greater_than_current<=0 || smallest_poc_greater_than_current>=h->short_ref_count) && (1 < index)){

  3968.                     // swap the two first elements of L1 when

  3969.                     // L0 and L1 are identical

  3970.                     Picture temp= h->default_ref_list[1][0];

  3971.                     h->default_ref_list[1][0] = h->default_ref_list[1][1];

  3972.                     h->default_ref_list[1][1] = temp;

  3973.                 }

  3974. 

  3975.                 if(index < h->ref_count[ list ])

  3976.                     memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index));

  3977.             }

  3978.         }else{

  3979.             int index=0;

  3980.             for(i=0; i<h->short_ref_count; i++){

  3981.                 if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit

  3982.                 h->default_ref_list[0][index  ]= *h->short_ref[i];

  3983.                 h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num;

  3984.             }

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

  3986.                 if(h->long_ref[i] == NULL) continue;

  3987.                 if(h->long_ref[i]->reference != 3) continue;

  3988.                 h->default_ref_list[0][index  ]= *h->long_ref[i];

  3989.                 h->default_ref_list[0][index++].pic_id= i;;

  3990.             }

  3991.             if(index < h->ref_count[0])

  3992.                 memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index));

  3993.         }

  3994.     }else{ //FIELD

  3995.         if(h->slice_type==B_TYPE){

  3996.         }else{

  3997.             //FIXME second field balh

  3998.         }

  3999.     }

  4000. #ifdef TRACE

  4001.     for (i=0; i<h->ref_count[0]; i++) {

  4002.         tprintf("List0: %s fn:%d 0x%p\n", (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]);

  4003.     }

  4004.     if(h->slice_type==B_TYPE){

  4005.         for (i=0; i<h->ref_count[1]; i++) {

  4006.             tprintf("List1: %s fn:%d 0x%p\n", (h->default_ref_list[1][i].long_ref ? "LT" : "ST"), h->default_ref_list[1][i].pic_id, h->default_ref_list[0][i].data[0]);

  4007.         }

  4008.     }

  4009. #endif

  4010.     return 0;

  4011. }

  4012. 

  4013. static void print_short_term(H264Context *h);

  4014. static void print_long_term(H264Context *h);

  4015. 

  4016. static int decode_ref_pic_list_reordering(H264Context *h){

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

  4018.     int list, index;

  4019. 

  4020.     print_short_term(h);

  4021.     print_long_term(h);

  4022.     if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move before func

  4023. 

  4024.     for(list=0; list<2; list++){

  4025.         memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]);

  4026. 

  4027.         if(get_bits1(&s->gb)){

  4028.             int pred= h->curr_pic_num;

  4029. 

  4030.             for(index=0; ; index++){

  4031.                 int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb);

  4032.                 int pic_id;

  4033.                 int i;

  4034.                 Picture *ref = NULL;

  4035. 

  4036.                 if(reordering_of_pic_nums_idc==3)

  4037.                     break;

  4038. 

  4039.                 if(index >= h->ref_count[list]){

  4040.                     av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n");

  4041.                     return -1;

  4042.                 }

  4043. 

  4044.                 if(reordering_of_pic_nums_idc<3){

  4045.                     if(reordering_of_pic_nums_idc<2){

  4046.                         const int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1;

  4047. 

  4048.                         if(abs_diff_pic_num >= h->max_pic_num){

  4049.                             av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n");

  4050.                             return -1;

  4051.                         }

  4052. 

  4053.                         if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num;

  4054.                         else                                pred+= abs_diff_pic_num;

  4055.                         pred &= h->max_pic_num - 1;

  4056. 

  4057.                         for(i= h->short_ref_count-1; i>=0; i--){

  4058.                             ref = h->short_ref[i];

  4059.                             assert(ref->reference == 3);

  4060.                             assert(!ref->long_ref);

  4061.                             if(ref->data[0] != NULL && ref->frame_num == pred && ref->long_ref == 0) // ignore non existing pictures by testing data[0] pointer

  4062.                                 break;

  4063.                         }

  4064.                         if(i>=0)

  4065.                             ref->pic_id= ref->frame_num;

  4066.                     }else{

  4067.                         pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx

  4068.                         ref = h->long_ref[pic_id];

  4069.                         ref->pic_id= pic_id;

  4070.                         assert(ref->reference == 3);

  4071.                         assert(ref->long_ref);

  4072.                         i=0;

  4073.                     }

  4074. 

  4075.                     if (i < 0) {

  4076.                         av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n");

  4077.                         memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME

  4078.                     } else {

  4079.                         for(i=index; i+1<h->ref_count[list]; i++){

  4080.                             if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id)

  4081.                                 break;

  4082.                         }

  4083.                         for(; i > index; i--){

  4084.                             h->ref_list[list][i]= h->ref_list[list][i-1];

  4085.                         }

  4086.                         h->ref_list[list][index]= *ref;

  4087.                     }

  4088.                 }else{

  4089.                     av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n");

  4090.                     return -1;

  4091.                 }

  4092.             }

  4093.         }

  4094. 

  4095.         if(h->slice_type!=B_TYPE) break;

  4096.     }

  4097.     for(list=0; list<2; list++){

  4098.         for(index= 0; index < h->ref_count[list]; index++){

  4099.             if(!h->ref_list[list][index].data[0])

  4100.                 h->ref_list[list][index]= s->current_picture;

  4101.         }

  4102.         if(h->slice_type!=B_TYPE) break;

  4103.     }

  4104. 

  4105.     if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred)

  4106.         direct_dist_scale_factor(h);

  4107.     direct_ref_list_init(h);

  4108.     return 0;

  4109. }

  4110. 

  4111. static void fill_mbaff_ref_list(H264Context *h){

  4112.     int list, i, j;

  4113.     for(list=0; list<2; list++){

  4114.         for(i=0; i<h->ref_count[list]; i++){

  4115.             Picture *frame = &h->ref_list[list][i];

  4116.             Picture *field = &h->ref_list[list][16+2*i];

  4117.             field[0] = *frame;

  4118.             for(j=0; j<3; j++)

  4119.                 field[0].linesize[j] <<= 1;

  4120.             field[1] = field[0];

  4121.             for(j=0; j<3; j++)

  4122.                 field[1].data[j] += frame->linesize[j];

  4123. 

  4124.             h->luma_weight[list][16+2*i] = h->luma_weight[list][16+2*i+1] = h->luma_weight[list][i];

  4125.             h->luma_offset[list][16+2*i] = h->luma_offset[list][16+2*i+1] = h->luma_offset[list][i];

  4126.             for(j=0; j<2; j++){

  4127.                 h->chroma_weight[list][16+2*i][j] = h->chroma_weight[list][16+2*i+1][j] = h->chroma_weight[list][i][j];

  4128.                 h->chroma_offset[list][16+2*i][j] = h->chroma_offset[list][16+2*i+1][j] = h->chroma_offset[list][i][j];

  4129.             }

  4130.         }

  4131.     }

  4132.     for(j=0; j<h->ref_count[1]; j++){

  4133.         for(i=0; i<h->ref_count[0]; i++)

  4134.             h->implicit_weight[j][16+2*i] = h->implicit_weight[j][16+2*i+1] = h->implicit_weight[j][i];

  4135.         memcpy(h->implicit_weight[16+2*j],   h->implicit_weight[j], sizeof(*h->implicit_weight));

  4136.         memcpy(h->implicit_weight[16+2*j+1], h->implicit_weight[j], sizeof(*h->implicit_weight));

  4137.     }

  4138. }

  4139. 

  4140. static int pred_weight_table(H264Context *h){

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

  4142.     int list, i;

  4143.     int luma_def, chroma_def;

  4144. 

  4145.     h->use_weight= 0;

  4146.     h->use_weight_chroma= 0;

  4147.     h->luma_log2_weight_denom= get_ue_golomb(&s->gb);

  4148.     h->chroma_log2_weight_denom= get_ue_golomb(&s->gb);

  4149.     luma_def = 1<<h->luma_log2_weight_denom;

  4150.     chroma_def = 1<<h->chroma_log2_weight_denom;

  4151. 

  4152.     for(list=0; list<2; list++){

  4153.         for(i=0; i<h->ref_count[list]; i++){

  4154.             int luma_weight_flag, chroma_weight_flag;

  4155. 

  4156.             luma_weight_flag= get_bits1(&s->gb);

  4157.             if(luma_weight_flag){

  4158.                 h->luma_weight[list][i]= get_se_golomb(&s->gb);

  4159.                 h->luma_offset[list][i]= get_se_golomb(&s->gb);

  4160.                 if(   h->luma_weight[list][i] != luma_def

  4161.                    || h->luma_offset[list][i] != 0)

  4162.                     h->use_weight= 1;

  4163.             }else{

  4164.                 h->luma_weight[list][i]= luma_def;

  4165.                 h->luma_offset[list][i]= 0;

  4166.             }

  4167. 

  4168.             chroma_weight_flag= get_bits1(&s->gb);

  4169.             if(chroma_weight_flag){

  4170.                 int j;

  4171.                 for(j=0; j<2; j++){

  4172.                     h->chroma_weight[list][i][j]= get_se_golomb(&s->gb);

  4173.                     h->chroma_offset[list][i][j]= get_se_golomb(&s->gb);

  4174.                     if(   h->chroma_weight[list][i][j] != chroma_def

  4175.                        || h->chroma_offset[list][i][j] != 0)

  4176.                         h->use_weight_chroma= 1;

  4177.                 }

  4178.             }else{

  4179.                 int j;

  4180.                 for(j=0; j<2; j++){

  4181.                     h->chroma_weight[list][i][j]= chroma_def;

  4182.                     h->chroma_offset[list][i][j]= 0;

  4183.                 }

  4184.             }

  4185.         }

  4186.         if(h->slice_type != B_TYPE) break;

  4187.     }

  4188.     h->use_weight= h->use_weight || h->use_weight_chroma;

  4189.     return 0;

  4190. }

  4191. 

  4192. static void implicit_weight_table(H264Context *h){

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

  4194.     int ref0, ref1;

  4195.     int cur_poc = s->current_picture_ptr->poc;

  4196. 

  4197.     if(   h->ref_count[0] == 1 && h->ref_count[1] == 1

  4198.        && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){

  4199.         h->use_weight= 0;

  4200.         h->use_weight_chroma= 0;

  4201.         return;

  4202.     }

  4203. 

  4204.     h->use_weight= 2;

  4205.     h->use_weight_chroma= 2;

  4206.     h->luma_log2_weight_denom= 5;

  4207.     h->chroma_log2_weight_denom= 5;

  4208. 

  4209.     for(ref0=0; ref0 < h->ref_count[0]; ref0++){

  4210.         int poc0 = h->ref_list[0][ref0].poc;

  4211.         for(ref1=0; ref1 < h->ref_count[1]; ref1++){

  4212.             int poc1 = h->ref_list[1][ref1].poc;

  4213.             int td = clip(poc1 - poc0, -128, 127);

  4214.             if(td){

  4215.                 int tb = clip(cur_poc - poc0, -128, 127);

  4216.                 int tx = (16384 + (FFABS(td) >> 1)) / td;

  4217.                 int dist_scale_factor = clip((tb*tx + 32) >> 6, -1024, 1023) >> 2;

  4218.                 if(dist_scale_factor < -64 || dist_scale_factor > 128)

  4219.                     h->implicit_weight[ref0][ref1] = 32;

  4220.                 else

  4221.                     h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor;

  4222.             }else

  4223.                 h->implicit_weight[ref0][ref1] = 32;

  4224.         }

  4225.     }

  4226. }

  4227. 

  4228. static inline void unreference_pic(H264Context *h, Picture *pic){

  4229.     int i;

  4230.     pic->reference=0;

  4231.     if(pic == h->delayed_output_pic)

  4232.         pic->reference=1;

  4233.     else{

  4234.         for(i = 0; h->delayed_pic[i]; i++)

  4235.             if(pic == h->delayed_pic[i]){

  4236.                 pic->reference=1;

  4237.                 break;

  4238.             }

  4239.     }

  4240. }

  4241. 

  4242. /**

  4243.  * instantaneous decoder refresh.

  4244.  */

  4245. static void idr(H264Context *h){

  4246.     int i;

  4247. 

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

  4249.         if (h->long_ref[i] != NULL) {

  4250.             unreference_pic(h, h->long_ref[i]);

  4251.             h->long_ref[i]= NULL;

  4252.         }

  4253.     }

  4254.     h->long_ref_count=0;

  4255. 

  4256.     for(i=0; i<h->short_ref_count; i++){

  4257.         unreference_pic(h, h->short_ref[i]);

  4258.         h->short_ref[i]= NULL;

  4259.     }

  4260.     h->short_ref_count=0;

  4261. }

  4262. 

  4263. /* forget old pics after a seek */

  4264. static void flush_dpb(AVCodecContext *avctx){

  4265.     H264Context *h= avctx->priv_data;

  4266.     int i;

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

  4268.         if(h->delayed_pic[i])

  4269.             h->delayed_pic[i]->reference= 0;

  4270.         h->delayed_pic[i]= NULL;

  4271.     }

  4272.     if(h->delayed_output_pic)

  4273.         h->delayed_output_pic->reference= 0;

  4274.     h->delayed_output_pic= NULL;

  4275.     idr(h);

  4276.     if(h->s.current_picture_ptr)

  4277.         h->s.current_picture_ptr->reference= 0;

  4278. }

  4279. 

  4280. /**

  4281.  *

  4282.  * @return the removed picture or NULL if an error occurs

  4283.  */

  4284. static Picture * remove_short(H264Context *h, int frame_num){

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

  4286.     int i;

  4287. 

  4288.     if(s->avctx->debug&FF_DEBUG_MMCO)

  4289.         av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);

  4290. 

  4291.     for(i=0; i<h->short_ref_count; i++){

  4292.         Picture *pic= h->short_ref[i];

  4293.         if(s->avctx->debug&FF_DEBUG_MMCO)

  4294.             av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);

  4295.         if(pic->frame_num == frame_num){

  4296.             h->short_ref[i]= NULL;

  4297.             memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*));

  4298.             h->short_ref_count--;

  4299.             return pic;

  4300.         }

  4301.     }

  4302.     return NULL;

  4303. }

  4304. 

  4305. /**

  4306.  *

  4307.  * @return the removed picture or NULL if an error occurs

  4308.  */

  4309. static Picture * remove_long(H264Context *h, int i){

  4310.     Picture *pic;

  4311. 

  4312.     pic= h->long_ref[i];

  4313.     h->long_ref[i]= NULL;

  4314.     if(pic) h->long_ref_count--;

  4315. 

  4316.     return pic;

  4317. }

  4318. 

  4319. /**

  4320.  * print short term list

  4321.  */

  4322. static void print_short_term(H264Context *h) {

  4323.     uint32_t i;

  4324.     if(h->s.avctx->debug&FF_DEBUG_MMCO) {

  4325.         av_log(h->s.avctx, AV_LOG_DEBUG, "short term list:\n");

  4326.         for(i=0; i<h->short_ref_count; i++){

  4327.             Picture *pic= h->short_ref[i];

  4328.             av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]);

  4329.         }

  4330.     }

  4331. }

  4332. 

  4333. /**

  4334.  * print long term list

  4335.  */

  4336. static void print_long_term(H264Context *h) {

  4337.     uint32_t i;

  4338.     if(h->s.avctx->debug&FF_DEBUG_MMCO) {

  4339.         av_log(h->s.avctx, AV_LOG_DEBUG, "long term list:\n");

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

  4341.             Picture *pic= h->long_ref[i];

  4342.             if (pic) {

  4343.                 av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]);

  4344.             }

  4345.         }

  4346.     }

  4347. }

  4348. 

  4349. /**

  4350.  * Executes the reference picture marking (memory management control operations).

  4351.  */

  4352. static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){

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

  4354.     int i, j;

  4355.     int current_is_long=0;

  4356.     Picture *pic;

  4357. 

  4358.     if((s->avctx->debug&FF_DEBUG_MMCO) && mmco_count==0)

  4359.         av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n");

  4360. 

  4361.     for(i=0; i<mmco_count; i++){

  4362.         if(s->avctx->debug&FF_DEBUG_MMCO)

  4363.             av_log(h->s.avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode, h->mmco[i].short_frame_num, h->mmco[i].long_index);

  4364. 

  4365.         switch(mmco[i].opcode){

  4366.         case MMCO_SHORT2UNUSED:

  4367.             pic= remove_short(h, mmco[i].short_frame_num);

  4368.             if(pic)

  4369.                 unreference_pic(h, pic);

  4370.             else if(s->avctx->debug&FF_DEBUG_MMCO)

  4371.                 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_short() failure\n");

  4372.             break;

  4373.         case MMCO_SHORT2LONG:

  4374.             pic= remove_long(h, mmco[i].long_index);

  4375.             if(pic) unreference_pic(h, pic);

  4376. 

  4377.             h->long_ref[ mmco[i].long_index ]= remove_short(h, mmco[i].short_frame_num);

  4378.             h->long_ref[ mmco[i].long_index ]->long_ref=1;

  4379.             h->long_ref_count++;

  4380.             break;

  4381.         case MMCO_LONG2UNUSED:

  4382.             pic= remove_long(h, mmco[i].long_index);

  4383.             if(pic)

  4384.                 unreference_pic(h, pic);

  4385.             else if(s->avctx->debug&FF_DEBUG_MMCO)

  4386.                 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_long() failure\n");

  4387.             break;

  4388.         case MMCO_LONG:

  4389.             pic= remove_long(h, mmco[i].long_index);

  4390.             if(pic) unreference_pic(h, pic);

  4391. 

  4392.             h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr;

  4393.             h->long_ref[ mmco[i].long_index ]->long_ref=1;

  4394.             h->long_ref_count++;

  4395. 

  4396.             current_is_long=1;

  4397.             break;

  4398.         case MMCO_SET_MAX_LONG:

  4399.             assert(mmco[i].long_index <= 16);

  4400.             // just remove the long term which index is greater than new max

  4401.             for(j = mmco[i].long_index; j<16; j++){

  4402.                 pic = remove_long(h, j);

  4403.                 if (pic) unreference_pic(h, pic);

  4404.             }

  4405.             break;

  4406.         case MMCO_RESET:

  4407.             while(h->short_ref_count){

  4408.                 pic= remove_short(h, h->short_ref[0]->frame_num);

  4409.                 unreference_pic(h, pic);

  4410.             }

  4411.             for(j = 0; j < 16; j++) {

  4412.                 pic= remove_long(h, j);

  4413.                 if(pic) unreference_pic(h, pic);

  4414.             }

  4415.             break;

  4416.         default: assert(0);

  4417.         }

  4418.     }

  4419. 

  4420.     if(!current_is_long){

  4421.         pic= remove_short(h, s->current_picture_ptr->frame_num);

  4422.         if(pic){

  4423.             unreference_pic(h, pic);

  4424.             av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");

  4425.         }

  4426. 

  4427.         if(h->short_ref_count)

  4428.             memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*));

  4429. 

  4430.         h->short_ref[0]= s->current_picture_ptr;

  4431.         h->short_ref[0]->long_ref=0;

  4432.         h->short_ref_count++;

  4433.     }

  4434. 

  4435.     print_short_term(h);

  4436.     print_long_term(h);

  4437.     return 0;

  4438. }

  4439. 

  4440. static int decode_ref_pic_marking(H264Context *h){

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

  4442.     int i;

  4443. 

  4444.     if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields

  4445.         s->broken_link= get_bits1(&s->gb) -1;

  4446.         h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx

  4447.         if(h->mmco[0].long_index == -1)

  4448.             h->mmco_index= 0;

  4449.         else{

  4450.             h->mmco[0].opcode= MMCO_LONG;

  4451.             h->mmco_index= 1;

  4452.         }

  4453.     }else{

  4454.         if(get_bits1(&s->gb)){ // adaptive_ref_pic_marking_mode_flag

  4455.             for(i= 0; i<MAX_MMCO_COUNT; i++) {

  4456.                 MMCOOpcode opcode= get_ue_golomb(&s->gb);;

  4457. 

  4458.                 h->mmco[i].opcode= opcode;

  4459.                 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){

  4460.                     h->mmco[i].short_frame_num= (h->frame_num - get_ue_golomb(&s->gb) - 1) & ((1<<h->sps.log2_max_frame_num)-1); //FIXME fields

  4461. /*                    if(h->mmco[i].short_frame_num >= h->short_ref_count || h->short_ref[ h->mmco[i].short_frame_num ] == NULL){

  4462.                         av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco);

  4463.                         return -1;

  4464.                     }*/

  4465.                 }

  4466.                 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){

  4467.                     h->mmco[i].long_index= get_ue_golomb(&s->gb);

  4468.                     if(/*h->mmco[i].long_index >= h->long_ref_count || h->long_ref[ h->mmco[i].long_index ] == NULL*/ h->mmco[i].long_index >= 16){

  4469.                         av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode);

  4470.                         return -1;

  4471.                     }

  4472.                 }

  4473. 

  4474.                 if(opcode > MMCO_LONG){

  4475.                     av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode);

  4476.                     return -1;

  4477.                 }

  4478.                 if(opcode == MMCO_END)

  4479.                     break;

  4480.             }

  4481.             h->mmco_index= i;

  4482.         }else{

  4483.             assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count);

  4484. 

  4485.             if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields

  4486.                 h->mmco[0].opcode= MMCO_SHORT2UNUSED;

  4487.                 h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num;

  4488.                 h->mmco_index= 1;

  4489.             }else

  4490.                 h->mmco_index= 0;

  4491.         }

  4492.     }

  4493. 

  4494.     return 0;

  4495. }

  4496. 

  4497. static int init_poc(H264Context *h){

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

  4499.     const int max_frame_num= 1<<h->sps.log2_max_frame_num;

  4500.     int field_poc[2];

  4501. 

  4502.     if(h->nal_unit_type == NAL_IDR_SLICE){

  4503.         h->frame_num_offset= 0;

  4504.     }else{

  4505.         if(h->frame_num < h->prev_frame_num)

  4506.             h->frame_num_offset= h->prev_frame_num_offset + max_frame_num;

  4507.         else

  4508.             h->frame_num_offset= h->prev_frame_num_offset;

  4509.     }

  4510. 

  4511.     if(h->sps.poc_type==0){

  4512.         const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb;

  4513. 

  4514.         if(h->nal_unit_type == NAL_IDR_SLICE){

  4515.              h->prev_poc_msb=

  4516.              h->prev_poc_lsb= 0;

  4517.         }

  4518. 

  4519.         if     (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2)

  4520.             h->poc_msb = h->prev_poc_msb + max_poc_lsb;

  4521.         else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2)

  4522.             h->poc_msb = h->prev_poc_msb - max_poc_lsb;

  4523.         else

  4524.             h->poc_msb = h->prev_poc_msb;

  4525. //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb);

  4526.         field_poc[0] =

  4527.         field_poc[1] = h->poc_msb + h->poc_lsb;

  4528.         if(s->picture_structure == PICT_FRAME)

  4529.             field_poc[1] += h->delta_poc_bottom;

  4530.     }else if(h->sps.poc_type==1){

  4531.         int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;

  4532.         int i;

  4533. 

  4534.         if(h->sps.poc_cycle_length != 0)

  4535.             abs_frame_num = h->frame_num_offset + h->frame_num;

  4536.         else

  4537.             abs_frame_num = 0;

  4538. 

  4539.         if(h->nal_ref_idc==0 && abs_frame_num > 0)

  4540.             abs_frame_num--;

  4541. 

  4542.         expected_delta_per_poc_cycle = 0;

  4543.         for(i=0; i < h->sps.poc_cycle_length; i++)

  4544.             expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse

  4545. 

  4546.         if(abs_frame_num > 0){

  4547.             int poc_cycle_cnt          = (abs_frame_num - 1) / h->sps.poc_cycle_length;

  4548.             int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length;

  4549. 

  4550.             expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;

  4551.             for(i = 0; i <= frame_num_in_poc_cycle; i++)

  4552.                 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ];

  4553.         } else

  4554.             expectedpoc = 0;

  4555. 

  4556.         if(h->nal_ref_idc == 0)

  4557.             expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic;

  4558. 

  4559.         field_poc[0] = expectedpoc + h->delta_poc[0];

  4560.         field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field;

  4561. 

  4562.         if(s->picture_structure == PICT_FRAME)

  4563.             field_poc[1] += h->delta_poc[1];

  4564.     }else{

  4565.         int poc;

  4566.         if(h->nal_unit_type == NAL_IDR_SLICE){

  4567.             poc= 0;

  4568.         }else{

  4569.             if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num);

  4570.             else               poc= 2*(h->frame_num_offset + h->frame_num) - 1;

  4571.         }

  4572.         field_poc[0]= poc;

  4573.         field_poc[1]= poc;

  4574.     }

  4575. 

  4576.     if(s->picture_structure != PICT_BOTTOM_FIELD)

  4577.         s->current_picture_ptr->field_poc[0]= field_poc[0];

  4578.     if(s->picture_structure != PICT_TOP_FIELD)

  4579.         s->current_picture_ptr->field_poc[1]= field_poc[1];

  4580.     if(s->picture_structure == PICT_FRAME) // FIXME field pix?

  4581.         s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]);

  4582. 

  4583.     return 0;

  4584. }

  4585. 

  4586. /**

  4587.  * decodes a slice header.

  4588.  * this will allso call MPV_common_init() and frame_start() as needed

  4589.  */

  4590. static int decode_slice_header(H264Context *h){

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

  4592.     int first_mb_in_slice, pps_id;

  4593.     int num_ref_idx_active_override_flag;

  4594.     static const uint8_t slice_type_map[5]= {P_TYPE, B_TYPE, I_TYPE, SP_TYPE, SI_TYPE};

  4595.     int slice_type;

  4596.     int default_ref_list_done = 0;

  4597. 

  4598.     s->current_picture.reference= h->nal_ref_idc != 0;

  4599.     s->dropable= h->nal_ref_idc == 0;

  4600. 

  4601.     first_mb_in_slice= get_ue_golomb(&s->gb);

  4602. 

  4603.     slice_type= get_ue_golomb(&s->gb);

  4604.     if(slice_type > 9){

  4605.         av_log(h->s.avctx, AV_LOG_ERROR, "slice type too large (%d) at %d %d\n", h->slice_type, s->mb_x, s->mb_y);

  4606.         return -1;

  4607.     }

  4608.     if(slice_type > 4){

  4609.         slice_type -= 5;

  4610.         h->slice_type_fixed=1;

  4611.     }else

  4612.         h->slice_type_fixed=0;

  4613. 

  4614.     slice_type= slice_type_map[ slice_type ];

  4615.     if (slice_type == I_TYPE

  4616.         || (h->slice_num != 0 && slice_type == h->slice_type) ) {

  4617.         default_ref_list_done = 1;

  4618.     }

  4619.     h->slice_type= slice_type;

  4620. 

  4621.     s->pict_type= h->slice_type; // to make a few old func happy, it's wrong though

  4622. 

  4623.     pps_id= get_ue_golomb(&s->gb);

  4624.     if(pps_id>255){

  4625.         av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");

  4626.         return -1;

  4627.     }

  4628.     h->pps= h->pps_buffer[pps_id];

  4629.     if(h->pps.slice_group_count == 0){

  4630.         av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n");

  4631.         return -1;

  4632.     }

  4633. 

  4634.     h->sps= h->sps_buffer[ h->pps.sps_id ];

  4635.     if(h->sps.log2_max_frame_num == 0){

  4636.         av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n");

  4637.         return -1;

  4638.     }

  4639. 

  4640.     if(h->dequant_coeff_pps != pps_id){

  4641.         h->dequant_coeff_pps = pps_id;

  4642.         init_dequant_tables(h);

  4643.     }

  4644. 

  4645.     s->mb_width= h->sps.mb_width;

  4646.     s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);

  4647. 

  4648.     h->b_stride=  s->mb_width*4;

  4649.     h->b8_stride= s->mb_width*2;

  4650. 

  4651.     s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right );

  4652.     if(h->sps.frame_mbs_only_flag)

  4653.         s->height= 16*s->mb_height - 2*(h->sps.crop_top  + h->sps.crop_bottom);

  4654.     else

  4655.         s->height= 16*s->mb_height - 4*(h->sps.crop_top  + h->sps.crop_bottom); //FIXME recheck

  4656. 

  4657.     if (s->context_initialized

  4658.         && (   s->width != s->avctx->width || s->height != s->avctx->height)) {

  4659.         free_tables(h);

  4660.         MPV_common_end(s);

  4661.     }

  4662.     if (!s->context_initialized) {

  4663.         if (MPV_common_init(s) < 0)

  4664.             return -1;

  4665. 

  4666.         if(s->dsp.h264_idct_add == ff_h264_idct_add_c){ //FIXME little ugly

  4667.             memcpy(h->zigzag_scan, zigzag_scan, 16*sizeof(uint8_t));

  4668.             memcpy(h-> field_scan,  field_scan, 16*sizeof(uint8_t));

  4669.         }else{

  4670.             int i;

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

  4672. #define T(x) (x>>2) | ((x<<2) & 0xF)

  4673.                 h->zigzag_scan[i] = T(zigzag_scan[i]);

  4674.                 h-> field_scan[i] = T( field_scan[i]);

  4675. #undef T

  4676.             }

  4677.         }

  4678.         if(s->dsp.h264_idct8_add == ff_h264_idct8_add_c){

  4679.             memcpy(h->zigzag_scan8x8,       zigzag_scan8x8,       64*sizeof(uint8_t));

  4680.             memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t));

  4681.             memcpy(h->field_scan8x8,        field_scan8x8,        64*sizeof(uint8_t));

  4682.             memcpy(h->field_scan8x8_cavlc,  field_scan8x8_cavlc,  64*sizeof(uint8_t));

  4683.         }else{

  4684.             int i;

  4685.             for(i=0; i<64; i++){

  4686. #define T(x) (x>>3) | ((x&7)<<3)

  4687.                 h->zigzag_scan8x8[i]       = T(zigzag_scan8x8[i]);

  4688.                 h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]);

  4689.                 h->field_scan8x8[i]        = T(field_scan8x8[i]);

  4690.                 h->field_scan8x8_cavlc[i]  = T(field_scan8x8_cavlc[i]);

  4691. #undef T

  4692.             }

  4693.         }

  4694.         if(h->sps.transform_bypass){ //FIXME same ugly

  4695.             h->zigzag_scan_q0          = zigzag_scan;

  4696.             h->zigzag_scan8x8_q0       = zigzag_scan8x8;

  4697.             h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc;

  4698.             h->field_scan_q0           = field_scan;

  4699.             h->field_scan8x8_q0        = field_scan8x8;

  4700.             h->field_scan8x8_cavlc_q0  = field_scan8x8_cavlc;

  4701.         }else{

  4702.             h->zigzag_scan_q0          = h->zigzag_scan;

  4703.             h->zigzag_scan8x8_q0       = h->zigzag_scan8x8;

  4704.             h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc;

  4705.             h->field_scan_q0           = h->field_scan;

  4706.             h->field_scan8x8_q0        = h->field_scan8x8;

  4707.             h->field_scan8x8_cavlc_q0  = h->field_scan8x8_cavlc;

  4708.         }

  4709. 

  4710.         alloc_tables(h);

  4711. 

  4712.         s->avctx->width = s->width;

  4713.         s->avctx->height = s->height;

  4714.         s->avctx->sample_aspect_ratio= h->sps.sar;

  4715.         if(!s->avctx->sample_aspect_ratio.den)

  4716.             s->avctx->sample_aspect_ratio.den = 1;

  4717. 

  4718.         if(h->sps.timing_info_present_flag){

  4719.             s->avctx->time_base= (AVRational){h->sps.num_units_in_tick * 2, h->sps.time_scale};

  4720.             if(h->x264_build > 0 && h->x264_build < 44)

  4721.                 s->avctx->time_base.den *= 2;

  4722.             av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,

  4723.                       s->avctx->time_base.num, s->avctx->time_base.den, 1<<30);

  4724.         }

  4725.     }

  4726. 

  4727.     if(h->slice_num == 0){

  4728.         if(frame_start(h) < 0)

  4729.             return -1;

  4730.     }

  4731. 

  4732.     s->current_picture_ptr->frame_num= //FIXME frame_num cleanup

  4733.     h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num);

  4734. 

  4735.     h->mb_mbaff = 0;

  4736.     h->mb_aff_frame = 0;

  4737.     if(h->sps.frame_mbs_only_flag){

  4738.         s->picture_structure= PICT_FRAME;

  4739.     }else{

  4740.         if(get_bits1(&s->gb)) { //field_pic_flag

  4741.             s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag

  4742.             av_log(h->s.avctx, AV_LOG_ERROR, "PAFF interlacing is not implemented\n");

  4743.         } else {

  4744.             s->picture_structure= PICT_FRAME;

  4745.             h->mb_aff_frame = h->sps.mb_aff;

  4746.         }

  4747.     }

  4748. 

  4749.     s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width;

  4750.     s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << h->mb_aff_frame;

  4751.     if(s->mb_y >= s->mb_height){

  4752.         return -1;

  4753.     }

  4754. 

  4755.     if(s->picture_structure==PICT_FRAME){

  4756.         h->curr_pic_num=   h->frame_num;

  4757.         h->max_pic_num= 1<< h->sps.log2_max_frame_num;

  4758.     }else{

  4759.         h->curr_pic_num= 2*h->frame_num;

  4760.         h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1);

  4761.     }

  4762. 

  4763.     if(h->nal_unit_type == NAL_IDR_SLICE){

  4764.         get_ue_golomb(&s->gb); /* idr_pic_id */

  4765.     }

  4766. 

  4767.     if(h->sps.poc_type==0){

  4768.         h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb);

  4769. 

  4770.         if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){

  4771.             h->delta_poc_bottom= get_se_golomb(&s->gb);

  4772.         }

  4773.     }

  4774. 

  4775.     if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){

  4776.         h->delta_poc[0]= get_se_golomb(&s->gb);

  4777. 

  4778.         if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME)

  4779.             h->delta_poc[1]= get_se_golomb(&s->gb);

  4780.     }

  4781. 

  4782.     init_poc(h);

  4783. 

  4784.     if(h->pps.redundant_pic_cnt_present){

  4785.         h->redundant_pic_count= get_ue_golomb(&s->gb);

  4786.     }

  4787. 

  4788.     //set defaults, might be overriden a few line later

  4789.     h->ref_count[0]= h->pps.ref_count[0];

  4790.     h->ref_count[1]= h->pps.ref_count[1];

  4791. 

  4792.     if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){

  4793.         if(h->slice_type == B_TYPE){

  4794.             h->direct_spatial_mv_pred= get_bits1(&s->gb);

  4795.             if(h->sps.mb_aff && h->direct_spatial_mv_pred)

  4796.                 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + spatial direct mode is not implemented\n");

  4797.         }

  4798.         num_ref_idx_active_override_flag= get_bits1(&s->gb);

  4799. 

  4800.         if(num_ref_idx_active_override_flag){

  4801.             h->ref_count[0]= get_ue_golomb(&s->gb) + 1;

  4802.             if(h->slice_type==B_TYPE)

  4803.                 h->ref_count[1]= get_ue_golomb(&s->gb) + 1;

  4804. 

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

  4806.                 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");

  4807.                 return -1;

  4808.             }

  4809.         }

  4810.     }

  4811. 

  4812.     if(!default_ref_list_done){

  4813.         fill_default_ref_list(h);

  4814.     }

  4815. 

  4816.     if(decode_ref_pic_list_reordering(h) < 0)

  4817.         return -1;

  4818. 

  4819.     if(   (h->pps.weighted_pred          && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE ))

  4820.        || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) )

  4821.         pred_weight_table(h);

  4822.     else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE)

  4823.         implicit_weight_table(h);

  4824.     else

  4825.         h->use_weight = 0;

  4826. 

  4827.     if(s->current_picture.reference)

  4828.         decode_ref_pic_marking(h);

  4829. 

  4830.     if(FRAME_MBAFF)

  4831.         fill_mbaff_ref_list(h);

  4832. 

  4833.     if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE && h->pps.cabac )

  4834.         h->cabac_init_idc = get_ue_golomb(&s->gb);

  4835. 

  4836.     h->last_qscale_diff = 0;

  4837.     s->qscale = h->pps.init_qp + get_se_golomb(&s->gb);

  4838.     if(s->qscale<0 || s->qscale>51){

  4839.         av_log(s->avctx, AV_LOG_ERROR, "QP %d out of range\n", s->qscale);

  4840.         return -1;

  4841.     }

  4842.     h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale);

  4843.     //FIXME qscale / qp ... stuff

  4844.     if(h->slice_type == SP_TYPE){

  4845.         get_bits1(&s->gb); /* sp_for_switch_flag */

  4846.     }

  4847.     if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){

  4848.         get_se_golomb(&s->gb); /* slice_qs_delta */

  4849.     }

  4850. 

  4851.     h->deblocking_filter = 1;

  4852.     h->slice_alpha_c0_offset = 0;

  4853.     h->slice_beta_offset = 0;

  4854.     if( h->pps.deblocking_filter_parameters_present ) {

  4855.         h->deblocking_filter= get_ue_golomb(&s->gb);

  4856.         if(h->deblocking_filter < 2)

  4857.             h->deblocking_filter^= 1; // 1<->0

  4858. 

  4859.         if( h->deblocking_filter ) {

  4860.             h->slice_alpha_c0_offset = get_se_golomb(&s->gb) << 1;

  4861.             h->slice_beta_offset = get_se_golomb(&s->gb) << 1;

  4862.         }

  4863.     }

  4864.     if(   s->avctx->skip_loop_filter >= AVDISCARD_ALL

  4865.        ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type != I_TYPE)

  4866.        ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR  && h->slice_type == B_TYPE)

  4867.        ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0))

  4868.         h->deblocking_filter= 0;

  4869. 

  4870. #if 0 //FMO

  4871.     if( h->pps.num_slice_groups > 1  && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5)

  4872.         slice_group_change_cycle= get_bits(&s->gb, ?);

  4873. #endif

  4874. 

  4875.     h->slice_num++;

  4876. 

  4877.     h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16;

  4878.     h->emu_edge_height= FRAME_MBAFF ? 0 : h->emu_edge_width;

  4879. 

  4880.     if(s->avctx->debug&FF_DEBUG_PICT_INFO){

  4881.         av_log(h->s.avctx, AV_LOG_DEBUG, "slice:%d %s mb:%d %c pps:%d frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s\n",

  4882.                h->slice_num,

  4883.                (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"),

  4884.                first_mb_in_slice,

  4885.                av_get_pict_type_char(h->slice_type),

  4886.                pps_id, h->frame_num,

  4887.                s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1],

  4888.                h->ref_count[0], h->ref_count[1],

  4889.                s->qscale,

  4890.                h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2,

  4891.                h->use_weight,

  4892.                h->use_weight==1 && h->use_weight_chroma ? "c" : ""

  4893.                );

  4894.     }

  4895. 

  4896.     if((s->avctx->flags2 & CODEC_FLAG2_FAST) && !s->current_picture.reference){

  4897.         s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab;

  4898.         s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab;

  4899.     }else{

  4900.         s->me.qpel_put= s->dsp.put_h264_qpel_pixels_tab;

  4901.         s->me.qpel_avg= s->dsp.avg_h264_qpel_pixels_tab;

  4902.     }

  4903. 

  4904.     return 0;

  4905. }

  4906. 

  4907. /**

  4908.  *

  4909.  */

  4910. static inline int get_level_prefix(GetBitContext *gb){

  4911.     unsigned int buf;

  4912.     int log;

  4913. 

  4914.     OPEN_READER(re, gb);

  4915.     UPDATE_CACHE(re, gb);

  4916.     buf=GET_CACHE(re, gb);

  4917. 

  4918.     log= 32 - av_log2(buf);

  4919. #ifdef TRACE

  4920.     print_bin(buf>>(32-log), log);

  4921.     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d lpr @%5d in %s get_level_prefix\n", buf>>(32-log), log, log-1, get_bits_count(gb), __FILE__);

  4922. #endif

  4923. 

  4924.     LAST_SKIP_BITS(re, gb, log);

  4925.     CLOSE_READER(re, gb);

  4926. 

  4927.     return log-1;

  4928. }

  4929. 

  4930. static inline int get_dct8x8_allowed(H264Context *h){

  4931.     int i;

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

  4933.         if(!IS_SUB_8X8(h->sub_mb_type[i])

  4934.            || (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i])))

  4935.             return 0;

  4936.     }

  4937.     return 1;

  4938. }

  4939. 

  4940. /**

  4941.  * decodes a residual block.

  4942.  * @param n block index

  4943.  * @param scantable scantable

  4944.  * @param max_coeff number of coefficients in the block

  4945.  * @return <0 if an error occured

  4946.  */

  4947. static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){

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

  4949.     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};

  4950.     int level[16];

  4951.     int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before;

  4952. 

  4953.     //FIXME put trailing_onex into the context

  4954. 

  4955.     if(n == CHROMA_DC_BLOCK_INDEX){

  4956.         coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);

  4957.         total_coeff= coeff_token>>2;

  4958.     }else{

  4959.         if(n == LUMA_DC_BLOCK_INDEX){

  4960.             total_coeff= pred_non_zero_count(h, 0);

  4961.             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);

  4962.             total_coeff= coeff_token>>2;

  4963.         }else{

  4964.             total_coeff= pred_non_zero_count(h, n);

  4965.             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);

  4966.             total_coeff= coeff_token>>2;

  4967.             h->non_zero_count_cache[ scan8[n] ]= total_coeff;

  4968.         }

  4969.     }

  4970. 

  4971.     //FIXME set last_non_zero?

  4972. 

  4973.     if(total_coeff==0)

  4974.         return 0;

  4975. 

  4976.     trailing_ones= coeff_token&3;

  4977.     tprintf("trailing:%d, total:%d\n", trailing_ones, total_coeff);

  4978.     assert(total_coeff<=16);

  4979. 

  4980.     for(i=0; i<trailing_ones; i++){

  4981.         level[i]= 1 - 2*get_bits1(gb);

  4982.     }

  4983. 

  4984.     if(i<total_coeff) {

  4985.         int level_code, mask;

  4986.         int suffix_length = total_coeff > 10 && trailing_ones < 3;

  4987.         int prefix= get_level_prefix(gb);

  4988. 

  4989.         //first coefficient has suffix_length equal to 0 or 1

  4990.         if(prefix<14){ //FIXME try to build a large unified VLC table for all this

  4991.             if(suffix_length)

  4992.                 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part

  4993.             else

  4994.                 level_code= (prefix<<suffix_length); //part

  4995.         }else if(prefix==14){

  4996.             if(suffix_length)

  4997.                 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part

  4998.             else

  4999.                 level_code= prefix + get_bits(gb, 4); //part

  5000.         }else if(prefix==15){

  5001.             level_code= (prefix<<suffix_length) + get_bits(gb, 12); //part

  5002.             if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense

  5003.         }else{

  5004.             av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y);

  5005.             return -1;

  5006.         }

  5007. 

  5008.         if(trailing_ones < 3) level_code += 2;

  5009. 

  5010.         suffix_length = 1;

  5011.         if(level_code > 5)

  5012.             suffix_length++;

  5013.         mask= -(level_code&1);

  5014.         level[i]= (((2+level_code)>>1) ^ mask) - mask;

  5015.         i++;

  5016. 

  5017.         //remaining coefficients have suffix_length > 0

  5018.         for(;i<total_coeff;i++) {

  5019.             static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX };

  5020.             prefix = get_level_prefix(gb);

  5021.             if(prefix<15){

  5022.                 level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);

  5023.             }else if(prefix==15){

  5024.                 level_code =  (prefix<<suffix_length) + get_bits(gb, 12);

  5025.             }else{

  5026.                 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y);

  5027.                 return -1;

  5028.             }

  5029.             mask= -(level_code&1);

  5030.             level[i]= (((2+level_code)>>1) ^ mask) - mask;

  5031.             if(level_code > suffix_limit[suffix_length])

  5032.                 suffix_length++;

  5033.         }

  5034.     }

  5035. 

  5036.     if(total_coeff == max_coeff)

  5037.         zeros_left=0;

  5038.     else{

  5039.         if(n == CHROMA_DC_BLOCK_INDEX)

  5040.             zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);

  5041.         else

  5042.             zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1);

  5043.     }

  5044. 

  5045.     coeff_num = zeros_left + total_coeff - 1;

  5046.     j = scantable[coeff_num];

  5047.     if(n > 24){

  5048.         block[j] = level[0];

  5049.         for(i=1;i<total_coeff;i++) {

  5050.             if(zeros_left <= 0)

  5051.                 run_before = 0;

  5052.             else if(zeros_left < 7){

  5053.                 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);

  5054.             }else{

  5055.                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);

  5056.             }

  5057.             zeros_left -= run_before;

  5058.             coeff_num -= 1 + run_before;

  5059.             j= scantable[ coeff_num ];

  5060. 

  5061.             block[j]= level[i];

  5062.         }

  5063.     }else{

  5064.         block[j] = (level[0] * qmul[j] + 32)>>6;

  5065.         for(i=1;i<total_coeff;i++) {

  5066.             if(zeros_left <= 0)

  5067.                 run_before = 0;

  5068.             else if(zeros_left < 7){

  5069.                 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);

  5070.             }else{

  5071.                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);

  5072.             }

  5073.             zeros_left -= run_before;

  5074.             coeff_num -= 1 + run_before;

  5075.             j= scantable[ coeff_num ];

  5076. 

  5077.             block[j]= (level[i] * qmul[j] + 32)>>6;

  5078.         }

  5079.     }

  5080. 

  5081.     if(zeros_left<0){

  5082.         av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);

  5083.         return -1;

  5084.     }

  5085. 

  5086.     return 0;

  5087. }

  5088. 

  5089. static void predict_field_decoding_flag(H264Context *h){

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

  5091.     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;

  5092.     int mb_type = (h->slice_table[mb_xy-1] == h->slice_num)

  5093.                 ? s->current_picture.mb_type[mb_xy-1]

  5094.                 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num)

  5095.                 ? s->current_picture.mb_type[mb_xy-s->mb_stride]

  5096.                 : 0;

  5097.     h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;

  5098. }

  5099. 

  5100. /**

  5101.  * decodes a P_SKIP or B_SKIP macroblock

  5102.  */

  5103. static void decode_mb_skip(H264Context *h){

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

  5105.     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;

  5106.     int mb_type=0;

  5107. 

  5108.     memset(h->non_zero_count[mb_xy], 0, 16);

  5109.     memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui

  5110. 

  5111.     if(MB_FIELD)

  5112.         mb_type|= MB_TYPE_INTERLACED;

  5113. 

  5114.     if( h->slice_type == B_TYPE )

  5115.     {

  5116.         // just for fill_caches. pred_direct_motion will set the real mb_type

  5117.         mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP;

  5118. 

  5119.         fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ...

  5120.         pred_direct_motion(h, &mb_type);

  5121.         mb_type|= MB_TYPE_SKIP;

  5122.     }

  5123.     else

  5124.     {

  5125.         int mx, my;

  5126.         mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP;

  5127. 

  5128.         fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ...

  5129.         pred_pskip_motion(h, &mx, &my);

  5130.         fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);

  5131.         fill_rectangle(  h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4);

  5132.     }

  5133. 

  5134.     write_back_motion(h, mb_type);

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

  5136.     s->current_picture.qscale_table[mb_xy]= s->qscale;

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

  5138.     h->prev_mb_skipped= 1;

  5139. }

  5140. 

  5141. /**

  5142.  * decodes a macroblock

  5143.  * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed

  5144.  */

  5145. static int decode_mb_cavlc(H264Context *h){

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

  5147.     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;

  5148.     int mb_type, partition_count, cbp;

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

  5150. 

  5151.     s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong?

  5152. 

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

  5154.     cbp = 0; /* avoid warning. FIXME: find a solution without slowing

  5155.                 down the code */

  5156.     if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){

  5157.         if(s->mb_skip_run==-1)

  5158.             s->mb_skip_run= get_ue_golomb(&s->gb);

  5159. 

  5160.         if (s->mb_skip_run--) {

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

  5162.                 if(s->mb_skip_run==0)

  5163.                     h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);

  5164.                 else

  5165.                     predict_field_decoding_flag(h);

  5166.             }

  5167.             decode_mb_skip(h);

  5168.             return 0;

  5169.         }

  5170.     }

  5171.     if(FRAME_MBAFF){

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

  5173.             h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);

  5174.     }else

  5175.         h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME);

  5176. 

  5177.     h->prev_mb_skipped= 0;

  5178. 

  5179.     mb_type= get_ue_golomb(&s->gb);

  5180.     if(h->slice_type == B_TYPE){

  5181.         if(mb_type < 23){

  5182.             partition_count= b_mb_type_info[mb_type].partition_count;

  5183.             mb_type=         b_mb_type_info[mb_type].type;

  5184.         }else{

  5185.             mb_type -= 23;

  5186.             goto decode_intra_mb;

  5187.         }

  5188.     }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){

  5189.         if(mb_type < 5){

  5190.             partition_count= p_mb_type_info[mb_type].partition_count;

  5191.             mb_type=         p_mb_type_info[mb_type].type;

  5192.         }else{

  5193.             mb_type -= 5;

  5194.             goto decode_intra_mb;

  5195.         }

  5196.     }else{

  5197.        assert(h->slice_type == I_TYPE);

  5198. decode_intra_mb:

  5199.         if(mb_type > 25){

  5200.             av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);

  5201.             return -1;

  5202.         }

  5203.         partition_count=0;

  5204.         cbp= i_mb_type_info[mb_type].cbp;

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

  5206.         mb_type= i_mb_type_info[mb_type].type;

  5207.     }

  5208. 

  5209.     if(MB_FIELD)

  5210.         mb_type |= MB_TYPE_INTERLACED;

  5211. 

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

  5213. 

  5214.     if(IS_INTRA_PCM(mb_type)){

  5215.         unsigned int x, y;

  5216. 

  5217.         // we assume these blocks are very rare so we dont optimize it

  5218.         align_get_bits(&s->gb);

  5219. 

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

  5221.         for(y=0; y<16; y++){

  5222.             const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3);

  5223.             for(x=0; x<16; x++){

  5224.                 tprintf("LUMA ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8));

  5225.                 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8);

  5226.             }

  5227.         }

  5228.         for(y=0; y<8; y++){

  5229.             const int index= 256 + 4*(y&3) + 32*(y>>2);

  5230.             for(x=0; x<8; x++){

  5231.                 tprintf("CHROMA U ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8));

  5232.                 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8);

  5233.             }

  5234.         }

  5235.         for(y=0; y<8; y++){

  5236.             const int index= 256 + 64 + 4*(y&3) + 32*(y>>2);

  5237.             for(x=0; x<8; x++){

  5238.                 tprintf("CHROMA V ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8));

  5239.                 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8);

  5240.             }

  5241.         }

  5242. 

  5243.         // In deblocking, the quantizer is 0

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

  5245.         h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, 0);

  5246.         // All coeffs are present

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

  5248. 

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

  5250.         return 0;

  5251.     }

  5252. 

  5253.     if(MB_MBAFF){

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

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

  5256.     }

  5257. 

  5258.     fill_caches(h, mb_type, 0);

  5259. 

  5260.     //mb_pred

  5261.     if(IS_INTRA(mb_type)){

  5262. //            init_top_left_availability(h);

  5263.             if(IS_INTRA4x4(mb_type)){

  5264.                 int i;

  5265.                 int di = 1;

  5266.                 if(dct8x8_allowed && get_bits1(&s->gb)){

  5267.                     mb_type |= MB_TYPE_8x8DCT;

  5268.                     di = 4;

  5269.                 }

  5270. 

  5271. //                fill_intra4x4_pred_table(h);

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

  5273.                     int mode= pred_intra_mode(h, i);

  5274. 

  5275.                     if(!get_bits1(&s->gb)){

  5276.                         const int rem_mode= get_bits(&s->gb, 3);

  5277.                         mode = rem_mode + (rem_mode >= mode);

  5278.                     }

  5279. 

  5280.                     if(di==4)

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

  5282.                     else

  5283.                         h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;

  5284.                 }

  5285.                 write_back_intra_pred_mode(h);

  5286.                 if( check_intra4x4_pred_mode(h) < 0)

  5287.                     return -1;

  5288.             }else{

  5289.                 h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode);

  5290.                 if(h->intra16x16_pred_mode < 0)

  5291.                     return -1;

  5292.             }

  5293.             h->chroma_pred_mode= get_ue_golomb(&s->gb);

  5294. 

  5295.             h->chroma_pred_mode= check_intra_pred_mode(h, h->chroma_pred_mode);

  5296.             if(h->chroma_pred_mode < 0)

  5297.                 return -1;

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

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

  5300. 

  5301.         if(h->slice_type == B_TYPE){

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

  5303.                 h->sub_mb_type[i]= get_ue_golomb(&s->gb);

  5304.                 if(h->sub_mb_type[i] >=13){

  5305.                     av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);

  5306.                     return -1;

  5307.                 }

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

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

  5310.             }

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

  5312.                || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {

  5313.                 pred_direct_motion(h, &mb_type);

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

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

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

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

  5318.             }

  5319.         }else{

  5320.             assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ?

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

  5322.                 h->sub_mb_type[i]= get_ue_golomb(&s->gb);

  5323.                 if(h->sub_mb_type[i] >=4){

  5324.                     av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);

  5325.                     return -1;

  5326.                 }

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

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

  5329.             }

  5330.         }

  5331. 

  5332.         for(list=0; list<2; list++){

  5333.             int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];

  5334.             if(ref_count == 0) continue;

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

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

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

  5338.                     ref[list][i] = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip?

  5339.                 }else{

  5340.                  //FIXME

  5341.                     ref[list][i] = -1;

  5342.                 }

  5343.             }

  5344.         }

  5345. 

  5346.         if(dct8x8_allowed)

  5347.             dct8x8_allowed = get_dct8x8_allowed(h);

  5348. 

  5349.         for(list=0; list<2; list++){

  5350.             const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];

  5351.             if(ref_count == 0) continue;

  5352. 

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

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

  5355.                     h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];

  5356.                     continue;

  5357.                 }

  5358.                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ]=

  5359.                 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];

  5360. 

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

  5362.                     const int sub_mb_type= h->sub_mb_type[i];

  5363.                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;

  5364.                     for(j=0; j<sub_partition_count[i]; j++){

  5365.                         int mx, my;

  5366.                         const int index= 4*i + block_width*j;

  5367.                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];

  5368.                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);

  5369.                         mx += get_se_golomb(&s->gb);

  5370.                         my += get_se_golomb(&s->gb);

  5371.                         tprintf("final mv:%d %d\n", mx, my);

  5372. 

  5373.                         if(IS_SUB_8X8(sub_mb_type)){

  5374.                             mv_cache[ 0 ][0]= mv_cache[ 1 ][0]=

  5375.                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;

  5376.                             mv_cache[ 0 ][1]= mv_cache[ 1 ][1]=

  5377.                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;

  5378.                         }else if(IS_SUB_8X4(sub_mb_type)){

  5379.                             mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx;

  5380.                             mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my;

  5381.                         }else if(IS_SUB_4X8(sub_mb_type)){

  5382.                             mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx;

  5383.                             mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my;

  5384.                         }else{

  5385.                             assert(IS_SUB_4X4(sub_mb_type));

  5386.                             mv_cache[ 0 ][0]= mx;

  5387.                             mv_cache[ 0 ][1]= my;

  5388.                         }

  5389.                     }

  5390.                 }else{

  5391.                     uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];

  5392.                     p[0] = p[1]=

  5393.                     p[8] = p[9]= 0;

  5394.                 }

  5395.             }

  5396.         }

  5397.     }else if(IS_DIRECT(mb_type)){

  5398.         pred_direct_motion(h, &mb_type);

  5399.         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;

  5400.     }else{

  5401.         int list, mx, my, i;

  5402.          //FIXME we should set ref_idx_l? to 0 if we use that later ...

  5403.         if(IS_16X16(mb_type)){

  5404.             for(list=0; list<2; list++){

  5405.                 if(h->ref_count[list]>0){

  5406.                     if(IS_DIR(mb_type, 0, list)){

  5407.                         const int val= get_te0_golomb(&s->gb, h->ref_count[list]);

  5408.                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);

  5409.                     }else

  5410.                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (LIST_NOT_USED&0xFF), 1);

  5411.                 }

  5412.             }

  5413.             for(list=0; list<2; list++){

  5414.                 if(IS_DIR(mb_type, 0, list)){

  5415.                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);

  5416.                     mx += get_se_golomb(&s->gb);

  5417.                     my += get_se_golomb(&s->gb);

  5418.                     tprintf("final mv:%d %d\n", mx, my);

  5419. 

  5420.                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);

  5421.                 }else

  5422.                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);

  5423.             }

  5424.         }

  5425.         else if(IS_16X8(mb_type)){

  5426.             for(list=0; list<2; list++){

  5427.                 if(h->ref_count[list]>0){

  5428.                     for(i=0; i<2; i++){

  5429.                         if(IS_DIR(mb_type, i, list)){

  5430.                             const int val= get_te0_golomb(&s->gb, h->ref_count[list]);

  5431.                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);

  5432.                         }else

  5433.                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);

  5434.                     }

  5435.                 }

  5436.             }

  5437.             for(list=0; list<2; list++){

  5438.                 for(i=0; i<2; i++){

  5439.                     if(IS_DIR(mb_type, i, list)){

  5440.                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);

  5441.                         mx += get_se_golomb(&s->gb);

  5442.                         my += get_se_golomb(&s->gb);

  5443.                         tprintf("final mv:%d %d\n", mx, my);

  5444. 

  5445.                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);

  5446.                     }else

  5447.                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);

  5448.                 }

  5449.             }

  5450.         }else{

  5451.             assert(IS_8X16(mb_type));

  5452.             for(list=0; list<2; list++){

  5453.                 if(h->ref_count[list]>0){

  5454.                     for(i=0; i<2; i++){

  5455.                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize

  5456.                             const int val= get_te0_golomb(&s->gb, h->ref_count[list]);

  5457.                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);

  5458.                         }else

  5459.                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);

  5460.                     }

  5461.                 }

  5462.             }

  5463.             for(list=0; list<2; list++){

  5464.                 for(i=0; i<2; i++){

  5465.                     if(IS_DIR(mb_type, i, list)){

  5466.                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);

  5467.                         mx += get_se_golomb(&s->gb);

  5468.                         my += get_se_golomb(&s->gb);

  5469.                         tprintf("final mv:%d %d\n", mx, my);

  5470. 

  5471.                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);

  5472.                     }else

  5473.                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);

  5474.                 }

  5475.             }

  5476.         }

  5477.     }

  5478. 

  5479.     if(IS_INTER(mb_type))

  5480.         write_back_motion(h, mb_type);

  5481. 

  5482.     if(!IS_INTRA16x16(mb_type)){

  5483.         cbp= get_ue_golomb(&s->gb);

  5484.         if(cbp > 47){

  5485.             av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%d) at %d %d\n", cbp, s->mb_x, s->mb_y);

  5486.             return -1;

  5487.         }

  5488. 

  5489.         if(IS_INTRA4x4(mb_type))

  5490.             cbp= golomb_to_intra4x4_cbp[cbp];

  5491.         else

  5492.             cbp= golomb_to_inter_cbp[cbp];

  5493.     }

  5494.     h->cbp = cbp;

  5495. 

  5496.     if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){

  5497.         if(get_bits1(&s->gb))

  5498.             mb_type |= MB_TYPE_8x8DCT;

  5499.     }

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

  5501. 

  5502.     if(cbp || IS_INTRA16x16(mb_type)){

  5503.         int i8x8, i4x4, chroma_idx;

  5504.         int chroma_qp, dquant;

  5505.         GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;

  5506.         const uint8_t *scan, *scan8x8, *dc_scan;

  5507. 

  5508. //        fill_non_zero_count_cache(h);

  5509. 

  5510.         if(IS_INTERLACED(mb_type)){

  5511.             scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;

  5512.             scan= s->qscale ? h->field_scan : h->field_scan_q0;

  5513.             dc_scan= luma_dc_field_scan;

  5514.         }else{

  5515.             scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;

  5516.             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;

  5517.             dc_scan= luma_dc_zigzag_scan;

  5518.         }

  5519. 

  5520.         dquant= get_se_golomb(&s->gb);

  5521. 

  5522.         if( dquant > 25 || dquant < -26 ){

  5523.             av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);

  5524.             return -1;

  5525.         }

  5526. 

  5527.         s->qscale += dquant;

  5528.         if(((unsigned)s->qscale) > 51){

  5529.             if(s->qscale<0) s->qscale+= 52;

  5530.             else            s->qscale-= 52;

  5531.         }

  5532. 

  5533.         h->chroma_qp= chroma_qp= get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale);

  5534.         if(IS_INTRA16x16(mb_type)){

  5535.             if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){

  5536.                 return -1; //FIXME continue if partitioned and other return -1 too

  5537.             }

  5538. 

  5539.             assert((cbp&15) == 0 || (cbp&15) == 15);

  5540. 

  5541.             if(cbp&15){

  5542.                 for(i8x8=0; i8x8<4; i8x8++){

  5543.                     for(i4x4=0; i4x4<4; i4x4++){

  5544.                         const int index= i4x4 + 4*i8x8;

  5545.                         if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){

  5546.                             return -1;

  5547.                         }

  5548.                     }

  5549.                 }

  5550.             }else{

  5551.                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);

  5552.             }

  5553.         }else{

  5554.             for(i8x8=0; i8x8<4; i8x8++){

  5555.                 if(cbp & (1<<i8x8)){

  5556.                     if(IS_8x8DCT(mb_type)){

  5557.                         DCTELEM *buf = &h->mb[64*i8x8];

  5558.                         uint8_t *nnz;

  5559.                         for(i4x4=0; i4x4<4; i4x4++){

  5560.                             if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4,

  5561.                                                 h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 )

  5562.                                 return -1;

  5563.                         }

  5564.                         nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];

  5565.                         nnz[0] += nnz[1] + nnz[8] + nnz[9];

  5566.                     }else{

  5567.                         for(i4x4=0; i4x4<4; i4x4++){

  5568.                             const int index= i4x4 + 4*i8x8;

  5569. 

  5570.                             if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){

  5571.                                 return -1;

  5572.                             }

  5573.                         }

  5574.                     }

  5575.                 }else{

  5576.                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];

  5577.                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;

  5578.                 }

  5579.             }

  5580.         }

  5581. 

  5582.         if(cbp&0x30){

  5583.             for(chroma_idx=0; chroma_idx<2; chroma_idx++)

  5584.                 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){

  5585.                     return -1;

  5586.                 }

  5587.         }

  5588. 

  5589.         if(cbp&0x20){

  5590.             for(chroma_idx=0; chroma_idx<2; chroma_idx++){

  5591.                 for(i4x4=0; i4x4<4; i4x4++){

  5592.                     const int index= 16 + 4*chroma_idx + i4x4;

  5593.                     if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][chroma_qp], 15) < 0){

  5594.                         return -1;

  5595.                     }

  5596.                 }

  5597.             }

  5598.         }else{

  5599.             uint8_t * const nnz= &h->non_zero_count_cache[0];

  5600.             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =

  5601.             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;

  5602.         }

  5603.     }else{

  5604.         uint8_t * const nnz= &h->non_zero_count_cache[0];

  5605.         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);

  5606.         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =

  5607.         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;

  5608.     }

  5609.     s->current_picture.qscale_table[mb_xy]= s->qscale;

  5610.     write_back_non_zero_count(h);

  5611. 

  5612.     if(MB_MBAFF){

  5613.         h->ref_count[0] >>= 1;

  5614.         h->ref_count[1] >>= 1;

  5615.     }

  5616. 

  5617.     return 0;

  5618. }

  5619. 

  5620. static int decode_cabac_field_decoding_flag(H264Context *h) {

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

  5622.     const int mb_x = s->mb_x;

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

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

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

  5626. 

  5627.     unsigned int ctx = 0;

  5628. 

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

  5630.         ctx += 1;

  5631.     }

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

  5633.         ctx += 1;

  5634.     }

  5635. 

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

  5637. }

  5638. 

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

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

  5641.     int mb_type;

  5642. 

  5643.     if(intra_slice){

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

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

  5646.         const int mbb_xy = h->top_mb_xy;

  5647.         int ctx=0;

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

  5649.             ctx++;

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

  5651.             ctx++;

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

  5653.             return 0;   /* I4x4 */

  5654.         state += 2;

  5655.     }else{

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

  5657.             return 0;   /* I4x4 */

  5658.     }

  5659. 

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

  5661.         return 25;  /* PCM */

  5662. 

  5663.     mb_type = 1; /* I16x16 */

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

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

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

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

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

  5669.     return mb_type;

  5670. }

  5671. 

  5672. static int decode_cabac_mb_type( H264Context *h ) {

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

  5674. 

  5675.     if( h->slice_type == I_TYPE ) {

  5676.         return decode_cabac_intra_mb_type(h, 3, 1);

  5677.     } else if( h->slice_type == P_TYPE ) {

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

  5679.             /* P-type */

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

  5681.                 /* P_L0_D16x16, P_8x8 */

  5682.                 return 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );

  5683.             } else {

  5684.                 /* P_L0_D8x16, P_L0_D16x8 */

  5685.                 return 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );

  5686.             }

  5687.         } else {

  5688.             return decode_cabac_intra_mb_type(h, 17, 0) + 5;

  5689.         }

  5690.     } else if( h->slice_type == B_TYPE ) {

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

  5692.         const int mbb_xy = h->top_mb_xy;

  5693.         int ctx = 0;

  5694.         int bits;

  5695. 

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

  5697.             ctx++;

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

  5699.             ctx++;

  5700. 

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

  5702.             return 0; /* B_Direct_16x16 */

  5703. 

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

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

  5706.         }

  5707. 

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

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

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

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

  5712.         if( bits < 8 )

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

  5714.         else if( bits == 13 ) {

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

  5716.         } else if( bits == 14 )

  5717.             return 11; /* B_L1_L0_8x16 */

  5718.         else if( bits == 15 )

  5719.             return 22; /* B_8x8 */

  5720. 

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

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

  5723.     } else {

  5724.         /* TODO SI/SP frames? */

  5725.         return -1;

  5726.     }

  5727. }

  5728. 

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

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

  5731.     int mba_xy, mbb_xy;

  5732.     int ctx = 0;

  5733. 

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

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

  5736.         mba_xy = mb_xy - 1;

  5737.         if( (mb_y&1)

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

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

  5740.             mba_xy += s->mb_stride;

  5741.         if( MB_FIELD ){

  5742.             mbb_xy = mb_xy - s->mb_stride;

  5743.             if( !(mb_y&1)

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

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

  5746.                 mbb_xy -= s->mb_stride;

  5747.         }else

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

  5749.     }else{

  5750.         int mb_xy = mb_x + mb_y*s->mb_stride;

  5751.         mba_xy = mb_xy - 1;

  5752.         mbb_xy = mb_xy - s->mb_stride;

  5753.     }

  5754. 

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

  5756.         ctx++;

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

  5758.         ctx++;

  5759. 

  5760.     if( h->slice_type == B_TYPE )

  5761.         ctx += 13;

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

  5763. }

  5764. 

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

  5766.     int mode = 0;

  5767. 

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

  5769.         return pred_mode;

  5770. 

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

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

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

  5774. 

  5775.     if( mode >= pred_mode )

  5776.         return mode + 1;

  5777.     else

  5778.         return mode;

  5779. }

  5780. 

  5781. static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {

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

  5783.     const int mbb_xy = h->top_mb_xy;

  5784. 

  5785.     int ctx = 0;

  5786. 

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

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

  5789.         ctx++;

  5790. 

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

  5792.         ctx++;

  5793. 

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

  5795.         return 0;

  5796. 

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

  5798.         return 1;

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

  5800.         return 2;

  5801.     else

  5802.         return 3;

  5803. }

  5804. 

  5805. static const uint8_t block_idx_x[16] = {

  5806.     0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3

  5807. };

  5808. static const uint8_t block_idx_y[16] = {

  5809.     0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3

  5810. };

  5811. static const uint8_t block_idx_xy[4][4] = {

  5812.     { 0, 2, 8,  10},

  5813.     { 1, 3, 9,  11},

  5814.     { 4, 6, 12, 14},

  5815.     { 5, 7, 13, 15}

  5816. };

  5817. 

  5818. static int decode_cabac_mb_cbp_luma( H264Context *h) {

  5819.     int cbp = 0;

  5820.     int cbp_b = -1;

  5821.     int i8x8;

  5822. 

  5823.     if( h->slice_table[h->top_mb_xy] == h->slice_num ) {

  5824.         cbp_b = h->top_cbp;

  5825.         tprintf("cbp_b = top_cbp = %x\n", cbp_b);

  5826.     }

  5827. 

  5828.     for( i8x8 = 0; i8x8 < 4; i8x8++ ) {

  5829.         int cbp_a = -1;

  5830.         int x, y;

  5831.         int ctx = 0;

  5832. 

  5833.         x = block_idx_x[4*i8x8];

  5834.         y = block_idx_y[4*i8x8];

  5835. 

  5836.         if( x > 0 )

  5837.             cbp_a = cbp;

  5838.         else if( h->slice_table[h->left_mb_xy[0]] == h->slice_num ) {

  5839.             cbp_a = h->left_cbp;

  5840.             tprintf("cbp_a = left_cbp = %x\n", cbp_a);

  5841.         }

  5842. 

  5843.         if( y > 0 )

  5844.             cbp_b = cbp;

  5845. 

  5846.         /* No need to test for skip as we put 0 for skip block */

  5847.         /* No need to test for IPCM as we put 1 for IPCM block */

  5848.         if( cbp_a >= 0 ) {

  5849.             int i8x8a = block_idx_xy[(x-1)&0x03][y]/4;

  5850.             if( ((cbp_a >> i8x8a)&0x01) == 0 )

  5851.                 ctx++;

  5852.         }

  5853. 

  5854.         if( cbp_b >= 0 ) {

  5855.             int i8x8b = block_idx_xy[x][(y-1)&0x03]/4;

  5856.             if( ((cbp_b >> i8x8b)&0x01) == 0 )

  5857.                 ctx += 2;

  5858.         }

  5859. 

  5860.         if( get_cabac( &h->cabac, &h->cabac_state[73 + ctx] ) ) {

  5861.             cbp |= 1 << i8x8;

  5862.         }

  5863.     }

  5864.     return cbp;

  5865. }

  5866. static int decode_cabac_mb_cbp_chroma( H264Context *h) {

  5867.     int ctx;

  5868.     int cbp_a, cbp_b;

  5869. 

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

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

  5872. 

  5873.     ctx = 0;

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

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

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

  5877.         return 0;

  5878. 

  5879.     ctx = 4;

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

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

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

  5883. }

  5884. static int decode_cabac_mb_dqp( H264Context *h) {

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

  5886.     int mbn_xy;

  5887.     int   ctx = 0;

  5888.     int   val = 0;

  5889. 

  5890.     if( s->mb_x > 0 )

  5891.         mbn_xy = s->mb_x + s->mb_y*s->mb_stride - 1;

  5892.     else

  5893.         mbn_xy = s->mb_width - 1 + (s->mb_y-1)*s->mb_stride;

  5894. 

  5895.     if( h->last_qscale_diff != 0 )

  5896.         ctx++;

  5897. 

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

  5899.         if( ctx < 2 )

  5900.             ctx = 2;

  5901.         else

  5902.             ctx = 3;

  5903.         val++;

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

  5905.             return INT_MIN;

  5906.     }

  5907. 

  5908.     if( val&0x01 )

  5909.         return (val + 1)/2;

  5910.     else

  5911.         return -(val + 1)/2;

  5912. }

  5913. static int decode_cabac_p_mb_sub_type( H264Context *h ) {

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

  5915.         return 0;   /* 8x8 */

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

  5917.         return 1;   /* 8x4 */

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

  5919.         return 2;   /* 4x8 */

  5920.     return 3;       /* 4x4 */

  5921. }

  5922. static int decode_cabac_b_mb_sub_type( H264Context *h ) {

  5923.     int type;

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

  5925.         return 0;   /* B_Direct_8x8 */

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

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

  5928.     type = 3;

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

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

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

  5932.         type += 4;

  5933.     }

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

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

  5936.     return type;

  5937. }

  5938. 

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

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

  5941. }

  5942. 

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

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

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

  5946.     int ref  = 0;

  5947.     int ctx  = 0;

  5948. 

  5949.     if( h->slice_type == B_TYPE) {

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

  5951.             ctx++;

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

  5953.             ctx += 2;

  5954.     } else {

  5955.         if( refa > 0 )

  5956.             ctx++;

  5957.         if( refb > 0 )

  5958.             ctx += 2;

  5959.     }

  5960. 

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

  5962.         ref++;

  5963.         if( ctx < 4 )

  5964.             ctx = 4;

  5965.         else

  5966.             ctx = 5;

  5967.     }

  5968.     return ref;

  5969. }

  5970. 

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

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

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

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

  5975.     int ctx, mvd;

  5976. 

  5977.     if( amvd < 3 )

  5978.         ctx = 0;

  5979.     else if( amvd > 32 )

  5980.         ctx = 2;

  5981.     else

  5982.         ctx = 1;

  5983. 

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

  5985.         return 0;

  5986. 

  5987.     mvd= 1;

  5988.     ctx= 3;

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

  5990.         mvd++;

  5991.         if( ctx < 6 )

  5992.             ctx++;

  5993.     }

  5994. 

  5995.     if( mvd >= 9 ) {

  5996.         int k = 3;

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

  5998.             mvd += 1 << k;

  5999.             k++;

  6000.         }

  6001.         while( k-- ) {

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

  6003.                 mvd += 1 << k;

  6004.         }

  6005.     }

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

  6007. }

  6008. 

  6009. static int inline get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) {

  6010.     int nza, nzb;

  6011.     int ctx = 0;

  6012. 

  6013.     if( cat == 0 ) {

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

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

  6016.     } else if( cat == 1 || cat == 2 ) {

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

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

  6019.     } else if( cat == 3 ) {

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

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

  6022.     } else {

  6023.         assert(cat == 4);

  6024.         nza = h->non_zero_count_cache[scan8[16+idx] - 1];

  6025.         nzb = h->non_zero_count_cache[scan8[16+idx] - 8];

  6026.     }

  6027. 

  6028.     if( nza > 0 )

  6029.         ctx++;

  6030. 

  6031.     if( nzb > 0 )

  6032.         ctx += 2;

  6033. 

  6034.     return ctx + 4 * cat;

  6035. }

  6036. 

  6037. static const __attribute((used)) uint8_t last_coeff_flag_offset_8x8[63] = {

  6038.     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  6039.     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  6040.     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,

  6041.     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8

  6042. };

  6043. 

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

  6045.     const int mb_xy  = h->s.mb_x + h->s.mb_y*h->s.mb_stride;

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

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

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

  6049.     };

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

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

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

  6053.     };

  6054.     static const int coeff_abs_level_m1_offset[6] = {

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

  6056.     };

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

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

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

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

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

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

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

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

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

  6066.     };

  6067. 

  6068.     int index[64];

  6069. 

  6070.     int last;

  6071.     int coeff_count = 0;

  6072. 

  6073.     int abslevel1 = 1;

  6074.     int abslevelgt1 = 0;

  6075. 

  6076.     uint8_t *significant_coeff_ctx_base;

  6077.     uint8_t *last_coeff_ctx_base;

  6078.     uint8_t *abs_level_m1_ctx_base;

  6079. 

  6080. #ifndef ARCH_X86

  6081. #define CABAC_ON_STACK

  6082. #endif

  6083. #ifdef CABAC_ON_STACK

  6084. #define CC &cc

  6085.     CABACContext cc;

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

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

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

  6089. #else

  6090. #define CC &h->cabac

  6091. #endif

  6092. 

  6093. 

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

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

  6096.      *      2-> Luma4x4   n = luma4x4idx

  6097.      *      3-> DC Chroma n = iCbCr

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

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

  6100.      */

  6101. 

  6102.     /* read coded block flag */

  6103.     if( cat != 5 ) {

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

  6105.             if( cat == 1 || cat == 2 )

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

  6107.             else if( cat == 4 )

  6108.                 h->non_zero_count_cache[scan8[16+n]] = 0;

  6109. #ifdef CABAC_ON_STACK

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

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

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

  6113. #endif

  6114.             return 0;

  6115.         }

  6116.     }

  6117. 

  6118.     significant_coeff_ctx_base = h->cabac_state

  6119.         + significant_coeff_flag_offset[MB_FIELD][cat];

  6120.     last_coeff_ctx_base = h->cabac_state

  6121.         + last_coeff_flag_offset[MB_FIELD][cat];

  6122.     abs_level_m1_ctx_base = h->cabac_state

  6123.         + coeff_abs_level_m1_offset[cat];

  6124. 

  6125.     if( cat == 5 ) {

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

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

  6128.             uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \

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

  6130.                 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \

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

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

  6133.                     last= max_coeff; \

  6134.                     break; \

  6135.                 } \

  6136.             } \

  6137.         }\

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

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

  6140.         }

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

  6142. #if defined(ARCH_X86) && !(defined(PIC) && defined(__GNUC__))

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

  6144.     } else {

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

  6146. #else

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

  6148.     } else {

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

  6150. #endif

  6151.     }

  6152.     assert(coeff_count > 0);

  6153. 

  6154.     if( cat == 0 )

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

  6156.     else if( cat == 1 || cat == 2 )

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

  6158.     else if( cat == 3 )

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

  6160.     else if( cat == 4 )

  6161.         h->non_zero_count_cache[scan8[16+n]] = coeff_count;

  6162.     else {

  6163.         assert( cat == 5 );

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

  6165.     }

  6166. 

  6167.     for( coeff_count--; coeff_count >= 0; coeff_count-- ) {

  6168.         uint8_t *ctx = (abslevelgt1 != 0 ? 0 : FFMIN( 4, abslevel1 )) + abs_level_m1_ctx_base;

  6169.         int j= scantable[index[coeff_count]];

  6170. 

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

  6172.             if( !qmul ) {

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

  6174.             }else{

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

  6176.             }

  6177. 

  6178.             abslevel1++;

  6179.         } else {

  6180.             int coeff_abs = 2;

  6181.             ctx = 5 + FFMIN( 4, abslevelgt1 ) + abs_level_m1_ctx_base;

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

  6183.                 coeff_abs++;

  6184.             }

  6185. 

  6186.             if( coeff_abs >= 15 ) {

  6187.                 int j = 0;

  6188.                 while( get_cabac_bypass( CC ) ) {

  6189.                     j++;

  6190.                 }

  6191. 

  6192.                 coeff_abs=1;

  6193.                 while( j-- ) {

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

  6195.                 }

  6196.                 coeff_abs+= 14;

  6197.             }

  6198. 

  6199.             if( !qmul ) {

  6200.                 if( get_cabac_bypass( CC ) ) block[j] = -coeff_abs;

  6201.                 else                                block[j] =  coeff_abs;

  6202.             }else{

  6203.                 if( get_cabac_bypass( CC ) ) block[j] = (-coeff_abs * qmul[j] + 32) >> 6;

  6204.                 else                                block[j] = ( coeff_abs * qmul[j] + 32) >> 6;

  6205.             }

  6206. 

  6207.             abslevelgt1++;

  6208.         }

  6209.     }

  6210. #ifdef CABAC_ON_STACK

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

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

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

  6214. #endif

  6215.     return 0;

  6216. }

  6217. 

  6218. static void inline compute_mb_neighbors(H264Context *h)

  6219. {

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

  6221.     const int mb_xy  = s->mb_x + s->mb_y*s->mb_stride;

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

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

  6224.     if(FRAME_MBAFF){

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

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

  6227.         const int top_mb_frame_flag      = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);

  6228.         const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);

  6229.         const int curr_mb_frame_flag = !MB_FIELD;

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

  6231.         if (bottom

  6232.                 ? !curr_mb_frame_flag // bottom macroblock

  6233.                 : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock

  6234.                 ) {

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

  6236.         }

  6237.         if (left_mb_frame_flag != curr_mb_frame_flag) {

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

  6239.         }

  6240.     }

  6241.     return;

  6242. }

  6243. 

  6244. /**

  6245.  * decodes a macroblock

  6246.  * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed

  6247.  */

  6248. static int decode_mb_cabac(H264Context *h) {

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

  6250.     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;

  6251.     int mb_type, partition_count, cbp = 0;

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

  6253. 

  6254.     s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong?)

  6255. 

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

  6257.     if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) {

  6258.         int skip;

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

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

  6261.             predict_field_decoding_flag(h);

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

  6263.             skip = h->next_mb_skipped;

  6264.         else

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

  6266.         /* read skip flags */

  6267.         if( skip ) {

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

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

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

  6271.                 if(h->next_mb_skipped)

  6272.                     predict_field_decoding_flag(h);

  6273.                 else

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

  6275.             }

  6276. 

  6277.             decode_mb_skip(h);

  6278. 

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

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

  6281.             h->last_qscale_diff = 0;

  6282. 

  6283.             return 0;

  6284. 

  6285.         }

  6286.     }

  6287.     if(FRAME_MBAFF){

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

  6289.             h->mb_mbaff =

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

  6291.     }else

  6292.         h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME);

  6293. 

  6294.     h->prev_mb_skipped = 0;

  6295. 

  6296.     compute_mb_neighbors(h);

  6297.     if( ( mb_type = decode_cabac_mb_type( h ) ) < 0 ) {

  6298.         av_log( h->s.avctx, AV_LOG_ERROR, "decode_cabac_mb_type failed\n" );

  6299.         return -1;

  6300.     }

  6301. 

  6302.     if( h->slice_type == B_TYPE ) {

  6303.         if( mb_type < 23 ){

  6304.             partition_count= b_mb_type_info[mb_type].partition_count;

  6305.             mb_type=         b_mb_type_info[mb_type].type;

  6306.         }else{

  6307.             mb_type -= 23;

  6308.             goto decode_intra_mb;

  6309.         }

  6310.     } else if( h->slice_type == P_TYPE ) {

  6311.         if( mb_type < 5) {

  6312.             partition_count= p_mb_type_info[mb_type].partition_count;

  6313.             mb_type=         p_mb_type_info[mb_type].type;

  6314.         } else {

  6315.             mb_type -= 5;

  6316.             goto decode_intra_mb;

  6317.         }

  6318.     } else {

  6319.        assert(h->slice_type == I_TYPE);

  6320. decode_intra_mb:

  6321.         partition_count = 0;

  6322.         cbp= i_mb_type_info[mb_type].cbp;

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

  6324.         mb_type= i_mb_type_info[mb_type].type;

  6325.     }

  6326.     if(MB_FIELD)

  6327.         mb_type |= MB_TYPE_INTERLACED;

  6328. 

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

  6330. 

  6331.     if(IS_INTRA_PCM(mb_type)) {

  6332.         const uint8_t *ptr;

  6333.         unsigned int x, y;

  6334. 

  6335.         // We assume these blocks are very rare so we dont optimize it.

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

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

  6338.         ptr= h->cabac.bytestream;

  6339.         if (h->cabac.low&0x1) ptr-=CABAC_BITS/8;

  6340. 

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

  6342.         for(y=0; y<16; y++){

  6343.             const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3);

  6344.             for(x=0; x<16; x++){

  6345.                 tprintf("LUMA ICPM LEVEL (%3d)\n", *ptr);

  6346.                 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= *ptr++;

  6347.             }

  6348.         }

  6349.         for(y=0; y<8; y++){

  6350.             const int index= 256 + 4*(y&3) + 32*(y>>2);

  6351.             for(x=0; x<8; x++){

  6352.                 tprintf("CHROMA U ICPM LEVEL (%3d)\n", *ptr);

  6353.                 h->mb[index + (x&3) + 16*(x>>2)]= *ptr++;

  6354.             }

  6355.         }

  6356.         for(y=0; y<8; y++){

  6357.             const int index= 256 + 64 + 4*(y&3) + 32*(y>>2);

  6358.             for(x=0; x<8; x++){

  6359.                 tprintf("CHROMA V ICPM LEVEL (%3d)\n", *ptr);

  6360.                 h->mb[index + (x&3) + 16*(x>>2)]= *ptr++;

  6361.             }

  6362.         }

  6363. 

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

  6365. 

  6366.         // All blocks are present

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

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

  6369.         // In deblocking, the quantizer is 0

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

  6371.         h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, 0);

  6372.         // All coeffs are present

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

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

  6375.         return 0;

  6376.     }

  6377. 

  6378.     if(MB_MBAFF){

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

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

  6381.     }

  6382. 

  6383.     fill_caches(h, mb_type, 0);

  6384. 

  6385.     if( IS_INTRA( mb_type ) ) {

  6386.         int i;

  6387.         if( IS_INTRA4x4( mb_type ) ) {

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

  6389.                 mb_type |= MB_TYPE_8x8DCT;

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

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

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

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

  6394.                 }

  6395.             } else {

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

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

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

  6399. 

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

  6401.                 }

  6402.             }

  6403.             write_back_intra_pred_mode(h);

  6404.             if( check_intra4x4_pred_mode(h) < 0 ) return -1;

  6405.         } else {

  6406.             h->intra16x16_pred_mode= check_intra_pred_mode( h, h->intra16x16_pred_mode );

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

  6408.         }

  6409.         h->chroma_pred_mode_table[mb_xy] =

  6410.             h->chroma_pred_mode          = decode_cabac_mb_chroma_pre_mode( h );

  6411. 

  6412.         h->chroma_pred_mode= check_intra_pred_mode( h, h->chroma_pred_mode );

  6413.         if( h->chroma_pred_mode < 0 ) return -1;

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

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

  6416. 

  6417.         if( h->slice_type == B_TYPE ) {

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

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

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

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

  6422.             }

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

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

  6425.                 pred_direct_motion(h, &mb_type);

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

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

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

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

  6430.                 }

  6431.             }

  6432.         } else {

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

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

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

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

  6437.             }

  6438.         }

  6439. 

  6440.         for( list = 0; list < 2; list++ ) {

  6441.             if( h->ref_count[list] > 0 ) {

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

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

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

  6445.                         if( h->ref_count[list] > 1 )

  6446.                             ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );

  6447.                         else

  6448.                             ref[list][i] = 0;

  6449.                     } else {

  6450.                         ref[list][i] = -1;

  6451.                     }

  6452.                                                        h->ref_cache[list][ scan8[4*i]+1 ]=

  6453.                     h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];

  6454.                 }

  6455.             }

  6456.         }

  6457. 

  6458.         if(dct8x8_allowed)

  6459.             dct8x8_allowed = get_dct8x8_allowed(h);

  6460. 

  6461.         for(list=0; list<2; list++){

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

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

  6464.                     fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);

  6465.                     continue;

  6466.                 }

  6467.                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];

  6468. 

  6469.                 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){

  6470.                     const int sub_mb_type= h->sub_mb_type[i];

  6471.                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;

  6472.                     for(j=0; j<sub_partition_count[i]; j++){

  6473.                         int mpx, mpy;

  6474.                         int mx, my;

  6475.                         const int index= 4*i + block_width*j;

  6476.                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];

  6477.                         int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];

  6478.                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);

  6479. 

  6480.                         mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );

  6481.                         my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );

  6482.                         tprintf("final mv:%d %d\n", mx, my);

  6483. 

  6484.                         if(IS_SUB_8X8(sub_mb_type)){

  6485.                             mv_cache[ 0 ][0]= mv_cache[ 1 ][0]=

  6486.                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;

  6487.                             mv_cache[ 0 ][1]= mv_cache[ 1 ][1]=

  6488.                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;

  6489. 

  6490.                             mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]=

  6491.                             mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;

  6492.                             mvd_cache[ 0 ][1]= mvd_cache[ 1 ][1]=

  6493.                             mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;

  6494.                         }else if(IS_SUB_8X4(sub_mb_type)){

  6495.                             mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx;

  6496.                             mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my;

  6497. 

  6498.                             mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]= mx- mpx;

  6499.                             mvd_cache[ 0 ][1]= mvd_cache[ 1 ][1]= my - mpy;

  6500.                         }else if(IS_SUB_4X8(sub_mb_type)){

  6501.                             mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx;

  6502.                             mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my;

  6503. 

  6504.                             mvd_cache[ 0 ][0]= mvd_cache[ 8 ][0]= mx - mpx;

  6505.                             mvd_cache[ 0 ][1]= mvd_cache[ 8 ][1]= my - mpy;

  6506.                         }else{

  6507.                             assert(IS_SUB_4X4(sub_mb_type));

  6508.                             mv_cache[ 0 ][0]= mx;

  6509.                             mv_cache[ 0 ][1]= my;

  6510. 

  6511.                             mvd_cache[ 0 ][0]= mx - mpx;

  6512.                             mvd_cache[ 0 ][1]= my - mpy;

  6513.                         }

  6514.                     }

  6515.                 }else{

  6516.                     uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];

  6517.                     uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];

  6518.                     p[0] = p[1] = p[8] = p[9] = 0;

  6519.                     pd[0]= pd[1]= pd[8]= pd[9]= 0;

  6520.                 }

  6521.             }

  6522.         }

  6523.     } else if( IS_DIRECT(mb_type) ) {

  6524.         pred_direct_motion(h, &mb_type);

  6525.         fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);

  6526.         fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);

  6527.         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;

  6528.     } else {

  6529.         int list, mx, my, i, mpx, mpy;

  6530.         if(IS_16X16(mb_type)){

  6531.             for(list=0; list<2; list++){

  6532.                 if(IS_DIR(mb_type, 0, list)){

  6533.                     if(h->ref_count[list] > 0 ){

  6534.                         const int ref = h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 0 ) : 0;

  6535.                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);

  6536.                     }

  6537.                 }else

  6538.                     fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1);

  6539.             }

  6540.             for(list=0; list<2; list++){

  6541.                 if(IS_DIR(mb_type, 0, list)){

  6542.                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);

  6543. 

  6544.                     mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );

  6545.                     my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );

  6546.                     tprintf("final mv:%d %d\n", mx, my);

  6547. 

  6548.                     fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4);

  6549.                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);

  6550.                 }else

  6551.                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);

  6552.             }

  6553.         }

  6554.         else if(IS_16X8(mb_type)){

  6555.             for(list=0; list<2; list++){

  6556.                 if(h->ref_count[list]>0){

  6557.                     for(i=0; i<2; i++){

  6558.                         if(IS_DIR(mb_type, i, list)){

  6559.                             const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 8*i ) : 0;

  6560.                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);

  6561.                         }else

  6562.                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);

  6563.                     }

  6564.                 }

  6565.             }

  6566.             for(list=0; list<2; list++){

  6567.                 for(i=0; i<2; i++){

  6568.                     if(IS_DIR(mb_type, i, list)){

  6569.                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);

  6570.                         mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );

  6571.                         my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );

  6572.                         tprintf("final mv:%d %d\n", mx, my);

  6573. 

  6574.                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);

  6575.                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);

  6576.                     }else{

  6577.                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);

  6578.                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);

  6579.                     }

  6580.                 }

  6581.             }

  6582.         }else{

  6583.             assert(IS_8X16(mb_type));

  6584.             for(list=0; list<2; list++){

  6585.                 if(h->ref_count[list]>0){

  6586.                     for(i=0; i<2; i++){

  6587.                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize

  6588.                             const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 4*i ) : 0;

  6589.                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);

  6590.                         }else

  6591.                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);

  6592.                     }

  6593.                 }

  6594.             }

  6595.             for(list=0; list<2; list++){

  6596.                 for(i=0; i<2; i++){

  6597.                     if(IS_DIR(mb_type, i, list)){

  6598.                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);

  6599.                         mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );

  6600.                         my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );

  6601. 

  6602.                         tprintf("final mv:%d %d\n", mx, my);

  6603.                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);

  6604.                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);

  6605.                     }else{

  6606.                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);

  6607.                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);

  6608.                     }

  6609.                 }

  6610.             }

  6611.         }

  6612.     }

  6613. 

  6614.    if( IS_INTER( mb_type ) ) {

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

  6616.         write_back_motion( h, mb_type );

  6617.    }

  6618. 

  6619.     if( !IS_INTRA16x16( mb_type ) ) {

  6620.         cbp  = decode_cabac_mb_cbp_luma( h );

  6621.         cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;

  6622.     }

  6623. 

  6624.     h->cbp_table[mb_xy] = h->cbp = cbp;

  6625. 

  6626.     if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {

  6627.         if( decode_cabac_mb_transform_size( h ) )

  6628.             mb_type |= MB_TYPE_8x8DCT;

  6629.     }

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

  6631. 

  6632.     if( cbp || IS_INTRA16x16( mb_type ) ) {

  6633.         const uint8_t *scan, *scan8x8, *dc_scan;

  6634.         int dqp;

  6635. 

  6636.         if(IS_INTERLACED(mb_type)){

  6637.             scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;

  6638.             scan= s->qscale ? h->field_scan : h->field_scan_q0;

  6639.             dc_scan= luma_dc_field_scan;

  6640.         }else{

  6641.             scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;

  6642.             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;

  6643.             dc_scan= luma_dc_zigzag_scan;

  6644.         }

  6645. 

  6646.         h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h );

  6647.         if( dqp == INT_MIN ){

  6648.             av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);

  6649.             return -1;

  6650.         }

  6651.         s->qscale += dqp;

  6652.         if(((unsigned)s->qscale) > 51){

  6653.             if(s->qscale<0) s->qscale+= 52;

  6654.             else            s->qscale-= 52;

  6655.         }

  6656.         h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale);

  6657. 

  6658.         if( IS_INTRA16x16( mb_type ) ) {

  6659.             int i;

  6660.             //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );

  6661.             if( decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16) < 0)

  6662.                 return -1;

  6663.             if( cbp&15 ) {

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

  6665.                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );

  6666.                     if( decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 )

  6667.                         return -1;

  6668.                 }

  6669.             } else {

  6670.                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);

  6671.             }

  6672.         } else {

  6673.             int i8x8, i4x4;

  6674.             for( i8x8 = 0; i8x8 < 4; i8x8++ ) {

  6675.                 if( cbp & (1<<i8x8) ) {

  6676.                     if( IS_8x8DCT(mb_type) ) {

  6677.                         if( decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,

  6678.                             scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64) < 0 )

  6679.                             return -1;

  6680.                     } else

  6681.                     for( i4x4 = 0; i4x4 < 4; i4x4++ ) {

  6682.                         const int index = 4*i8x8 + i4x4;

  6683.                         //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );

  6684. //START_TIMER

  6685.                         if( decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) < 0 )

  6686.                             return -1;

  6687. //STOP_TIMER("decode_residual")

  6688.                     }

  6689.                 } else {

  6690.                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];

  6691.                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;

  6692.                 }

  6693.             }

  6694.         }

  6695. 

  6696.         if( cbp&0x30 ){

  6697.             int c;

  6698.             for( c = 0; c < 2; c++ ) {

  6699.                 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );

  6700.                 if( decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4) < 0)

  6701.                     return -1;

  6702.             }

  6703.         }

  6704. 

  6705.         if( cbp&0x20 ) {

  6706.             int c, i;

  6707.             for( c = 0; c < 2; c++ ) {

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

  6709.                     const int index = 16 + 4 * c + i;

  6710.                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );

  6711.                     if( decode_cabac_residual(h, h->mb + 16*index, 4, index - 16, scan + 1, h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp], 15) < 0)

  6712.                         return -1;

  6713.                 }

  6714.             }

  6715.         } else {

  6716.             uint8_t * const nnz= &h->non_zero_count_cache[0];

  6717.             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =

  6718.             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;

  6719.         }

  6720.     } else {

  6721.         uint8_t * const nnz= &h->non_zero_count_cache[0];

  6722.         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);

  6723.         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =

  6724.         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;

  6725.         h->last_qscale_diff = 0;

  6726.     }

  6727. 

  6728.     s->current_picture.qscale_table[mb_xy]= s->qscale;

  6729.     write_back_non_zero_count(h);

  6730. 

  6731.     if(MB_MBAFF){

  6732.         h->ref_count[0] >>= 1;

  6733.         h->ref_count[1] >>= 1;

  6734.     }

  6735. 

  6736.     return 0;

  6737. }

  6738. 

  6739. 

  6740. static void filter_mb_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {

  6741.     int i, d;

  6742.     const int index_a = qp + h->slice_alpha_c0_offset;

  6743.     const int alpha = (alpha_table+52)[index_a];

  6744.     const int beta  = (beta_table+52)[qp + h->slice_beta_offset];

  6745. 

  6746.     if( bS[0] < 4 ) {

  6747.         int8_t tc[4];

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

  6749.             tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1;

  6750.         h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc);

  6751.     } else {

  6752.         /* 16px edge length, because bS=4 is triggered by being at

  6753.          * the edge of an intra MB, so all 4 bS are the same */

  6754.             for( d = 0; d < 16; d++ ) {

  6755.                 const int p0 = pix[-1];

  6756.                 const int p1 = pix[-2];

  6757.                 const int p2 = pix[-3];

  6758. 

  6759.                 const int q0 = pix[0];

  6760.                 const int q1 = pix[1];

  6761.                 const int q2 = pix[2];

  6762. 

  6763.                 if( FFABS( p0 - q0 ) < alpha &&

  6764.                     FFABS( p1 - p0 ) < beta &&

  6765.                     FFABS( q1 - q0 ) < beta ) {

  6766. 

  6767.                     if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){

  6768.                         if( FFABS( p2 - p0 ) < beta)

  6769.                         {

  6770.                             const int p3 = pix[-4];

  6771.                             /* p0', p1', p2' */

  6772.                             pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;

  6773.                             pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;

  6774.                             pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;

  6775.                         } else {

  6776.                             /* p0' */

  6777.                             pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;

  6778.                         }

  6779.                         if( FFABS( q2 - q0 ) < beta)

  6780.                         {

  6781.                             const int q3 = pix[3];

  6782.                             /* q0', q1', q2' */

  6783.                             pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;

  6784.                             pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;

  6785.                             pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;

  6786.                         } else {

  6787.                             /* q0' */

  6788.                             pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;

  6789.                         }

  6790.                     }else{

  6791.                         /* p0', q0' */

  6792.                         pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;

  6793.                         pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;

  6794.                     }

  6795.                     tprintf("filter_mb_edgev i:%d d:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, d, p2, p1, p0, q0, q1, q2, pix[-2], pix[-1], pix[0], pix[1]);

  6796.                 }

  6797.                 pix += stride;

  6798.             }

  6799.     }

  6800. }

  6801. static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {

  6802.     int i;

  6803.     const int index_a = qp + h->slice_alpha_c0_offset;

  6804.     const int alpha = (alpha_table+52)[index_a];

  6805.     const int beta  = (beta_table+52)[qp + h->slice_beta_offset];

  6806. 

  6807.     if( bS[0] < 4 ) {

  6808.         int8_t tc[4];

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

  6810.             tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0;

  6811.         h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc);

  6812.     } else {

  6813.         h->s.dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta);

  6814.     }

  6815. }

  6816. 

  6817. static void filter_mb_mbaff_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[8], int qp[2] ) {

  6818.     int i;

  6819.     for( i = 0; i < 16; i++, pix += stride) {

  6820.         int index_a;

  6821.         int alpha;

  6822.         int beta;

  6823. 

  6824.         int qp_index;

  6825.         int bS_index = (i >> 1);

  6826.         if (!MB_FIELD) {

  6827.             bS_index &= ~1;

  6828.             bS_index |= (i & 1);

  6829.         }

  6830. 

  6831.         if( bS[bS_index] == 0 ) {

  6832.             continue;

  6833.         }

  6834. 

  6835.         qp_index = MB_FIELD ? (i >> 3) : (i & 1);

  6836.         index_a = qp[qp_index] + h->slice_alpha_c0_offset;

  6837.         alpha = (alpha_table+52)[index_a];

  6838.         beta  = (beta_table+52)[qp[qp_index] + h->slice_beta_offset];

  6839. 

  6840.         if( bS[bS_index] < 4 ) {

  6841.             const int tc0 = (tc0_table+52)[index_a][bS[bS_index] - 1];

  6842.             const int p0 = pix[-1];

  6843.             const int p1 = pix[-2];

  6844.             const int p2 = pix[-3];

  6845.             const int q0 = pix[0];

  6846.             const int q1 = pix[1];

  6847.             const int q2 = pix[2];

  6848. 

  6849.             if( FFABS( p0 - q0 ) < alpha &&

  6850.                 FFABS( p1 - p0 ) < beta &&

  6851.                 FFABS( q1 - q0 ) < beta ) {

  6852.                 int tc = tc0;

  6853.                 int i_delta;

  6854. 

  6855.                 if( FFABS( p2 - p0 ) < beta ) {

  6856.                     pix[-2] = p1 + clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 );

  6857.                     tc++;

  6858.                 }

  6859.                 if( FFABS( q2 - q0 ) < beta ) {

  6860.                     pix[1] = q1 + clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 );

  6861.                     tc++;

  6862.                 }

  6863. 

  6864.                 i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );

  6865.                 pix[-1] = clip_uint8( p0 + i_delta );    /* p0' */

  6866.                 pix[0]  = clip_uint8( q0 - i_delta );    /* q0' */

  6867.                 tprintf("filter_mb_mbaff_edgev i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d, tc:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, tc, bS[bS_index], pix[-3], p1, p0, q0, q1, pix[2], p1, pix[-1], pix[0], q1);

  6868.             }

  6869.         }else{

  6870.             const int p0 = pix[-1];

  6871.             const int p1 = pix[-2];

  6872.             const int p2 = pix[-3];

  6873. 

  6874.             const int q0 = pix[0];

  6875.             const int q1 = pix[1];

  6876.             const int q2 = pix[2];

  6877. 

  6878.             if( FFABS( p0 - q0 ) < alpha &&

  6879.                 FFABS( p1 - p0 ) < beta &&

  6880.                 FFABS( q1 - q0 ) < beta ) {

  6881. 

  6882.                 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){

  6883.                     if( FFABS( p2 - p0 ) < beta)

  6884.                     {

  6885.                         const int p3 = pix[-4];

  6886.                         /* p0', p1', p2' */

  6887.                         pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;

  6888.                         pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;

  6889.                         pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;

  6890.                     } else {

  6891.                         /* p0' */

  6892.                         pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;

  6893.                     }

  6894.                     if( FFABS( q2 - q0 ) < beta)

  6895.                     {

  6896.                         const int q3 = pix[3];

  6897.                         /* q0', q1', q2' */

  6898.                         pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;

  6899.                         pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;

  6900.                         pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;

  6901.                     } else {

  6902.                         /* q0' */

  6903.                         pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;

  6904.                     }

  6905.                 }else{

  6906.                     /* p0', q0' */

  6907.                     pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;

  6908.                     pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;

  6909.                 }

  6910.                 tprintf("filter_mb_mbaff_edgev i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, p2, p1, p0, q0, q1, q2, pix[-3], pix[-2], pix[-1], pix[0], pix[1], pix[2]);

  6911.             }

  6912.         }

  6913.     }

  6914. }

  6915. static void filter_mb_mbaff_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[8], int qp[2] ) {

  6916.     int i;

  6917.     for( i = 0; i < 8; i++, pix += stride) {

  6918.         int index_a;

  6919.         int alpha;

  6920.         int beta;

  6921. 

  6922.         int qp_index;

  6923.         int bS_index = i;

  6924. 

  6925.         if( bS[bS_index] == 0 ) {

  6926.             continue;

  6927.         }

  6928. 

  6929.         qp_index = MB_FIELD ? (i >> 2) : (i & 1);

  6930.         index_a = qp[qp_index] + h->slice_alpha_c0_offset;

  6931.         alpha = (alpha_table+52)[index_a];

  6932.         beta  = (beta_table+52)[qp[qp_index] + h->slice_beta_offset];

  6933. 

  6934.         if( bS[bS_index] < 4 ) {

  6935.             const int tc = (tc0_table+52)[index_a][bS[bS_index] - 1] + 1;

  6936.             const int p0 = pix[-1];

  6937.             const int p1 = pix[-2];

  6938.             const int q0 = pix[0];

  6939.             const int q1 = pix[1];

  6940. 

  6941.             if( FFABS( p0 - q0 ) < alpha &&

  6942.                 FFABS( p1 - p0 ) < beta &&

  6943.                 FFABS( q1 - q0 ) < beta ) {

  6944.                 const int i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );

  6945. 

  6946.                 pix[-1] = clip_uint8( p0 + i_delta );    /* p0' */

  6947.                 pix[0]  = clip_uint8( q0 - i_delta );    /* q0' */

  6948.                 tprintf("filter_mb_mbaff_edgecv i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d, tc:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, tc, bS[bS_index], pix[-3], p1, p0, q0, q1, pix[2], p1, pix[-1], pix[0], q1);

  6949.             }

  6950.         }else{

  6951.             const int p0 = pix[-1];

  6952.             const int p1 = pix[-2];

  6953.             const int q0 = pix[0];

  6954.             const int q1 = pix[1];

  6955. 

  6956.             if( FFABS( p0 - q0 ) < alpha &&

  6957.                 FFABS( p1 - p0 ) < beta &&

  6958.                 FFABS( q1 - q0 ) < beta ) {

  6959. 

  6960.                 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;   /* p0' */

  6961.                 pix[0]  = ( 2*q1 + q0 + p1 + 2 ) >> 2;   /* q0' */

  6962.                 tprintf("filter_mb_mbaff_edgecv i:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x, %02x, %02x]\n", i, pix[-3], p1, p0, q0, q1, pix[2], pix[-3], pix[-2], pix[-1], pix[0], pix[1], pix[2]);

  6963.             }

  6964.         }

  6965.     }

  6966. }

  6967. 

  6968. static void filter_mb_edgeh( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {

  6969.     int i, d;

  6970.     const int index_a = qp + h->slice_alpha_c0_offset;

  6971.     const int alpha = (alpha_table+52)[index_a];

  6972.     const int beta  = (beta_table+52)[qp + h->slice_beta_offset];

  6973.     const int pix_next  = stride;

  6974. 

  6975.     if( bS[0] < 4 ) {

  6976.         int8_t tc[4];

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

  6978.             tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1;

  6979.         h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc);

  6980.     } else {

  6981.         /* 16px edge length, see filter_mb_edgev */

  6982.             for( d = 0; d < 16; d++ ) {

  6983.                 const int p0 = pix[-1*pix_next];

  6984.                 const int p1 = pix[-2*pix_next];

  6985.                 const int p2 = pix[-3*pix_next];

  6986.                 const int q0 = pix[0];

  6987.                 const int q1 = pix[1*pix_next];

  6988.                 const int q2 = pix[2*pix_next];

  6989. 

  6990.                 if( FFABS( p0 - q0 ) < alpha &&

  6991.                     FFABS( p1 - p0 ) < beta &&

  6992.                     FFABS( q1 - q0 ) < beta ) {

  6993. 

  6994.                     const int p3 = pix[-4*pix_next];

  6995.                     const int q3 = pix[ 3*pix_next];

  6996. 

  6997.                     if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){

  6998.                         if( FFABS( p2 - p0 ) < beta) {

  6999.                             /* p0', p1', p2' */

  7000.                             pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;

  7001.                             pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;

  7002.                             pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;

  7003.                         } else {

  7004.                             /* p0' */

  7005.                             pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2;

  7006.                         }

  7007.                         if( FFABS( q2 - q0 ) < beta) {

  7008.                             /* q0', q1', q2' */

  7009.                             pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;

  7010.                             pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;

  7011.                             pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;

  7012.                         } else {

  7013.                             /* q0' */

  7014.                             pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2;

  7015.                         }

  7016.                     }else{

  7017.                         /* p0', q0' */

  7018.                         pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2;

  7019.                         pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2;

  7020.                     }

  7021.                     tprintf("filter_mb_edgeh i:%d d:%d, qp:%d, indexA:%d, alpha:%d, beta:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, d, qp, index_a, alpha, beta, bS[i], p2, p1, p0, q0, q1, q2, pix[-2*pix_next], pix[-pix_next], pix[0], pix[pix_next]);

  7022.                 }

  7023.                 pix++;

  7024.             }

  7025.     }

  7026. }

  7027. 

  7028. static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {

  7029.     int i;

  7030.     const int index_a = qp + h->slice_alpha_c0_offset;

  7031.     const int alpha = (alpha_table+52)[index_a];

  7032.     const int beta  = (beta_table+52)[qp + h->slice_beta_offset];

  7033. 

  7034.     if( bS[0] < 4 ) {

  7035.         int8_t tc[4];

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

  7037.             tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0;

  7038.         h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc);

  7039.     } else {

  7040.         h->s.dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta);

  7041.     }

  7042. }

  7043. 

  7044. static void filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize) {

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

  7046.     int mb_xy, mb_type;

  7047.     int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh;

  7048. 

  7049.     if(mb_x==0 || mb_y==0 || !s->dsp.h264_loop_filter_strength) {

  7050.         filter_mb(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize);

  7051.         return;

  7052.     }

  7053.     assert(!FRAME_MBAFF);

  7054. 

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

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

  7057.     qp = s->current_picture.qscale_table[mb_xy];

  7058.     qp0 = s->current_picture.qscale_table[mb_xy-1];

  7059.     qp1 = s->current_picture.qscale_table[h->top_mb_xy];

  7060.     qpc = get_chroma_qp( h->pps.chroma_qp_index_offset, qp );

  7061.     qpc0 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp0 );

  7062.     qpc1 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp1 );

  7063.     qp0 = (qp + qp0 + 1) >> 1;

  7064.     qp1 = (qp + qp1 + 1) >> 1;

  7065.     qpc0 = (qpc + qpc0 + 1) >> 1;

  7066.     qpc1 = (qpc + qpc1 + 1) >> 1;

  7067.     qp_thresh = 15 - h->slice_alpha_c0_offset;

  7068.     if(qp <= qp_thresh && qp0 <= qp_thresh && qp1 <= qp_thresh &&

  7069.        qpc <= qp_thresh && qpc0 <= qp_thresh && qpc1 <= qp_thresh)

  7070.         return;

  7071. 

  7072.     if( IS_INTRA(mb_type) ) {

  7073.         int16_t bS4[4] = {4,4,4,4};

  7074.         int16_t bS3[4] = {3,3,3,3};

  7075.         if( IS_8x8DCT(mb_type) ) {

  7076.             filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 );

  7077.             filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp );

  7078.             filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 );

  7079.             filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp );

  7080.         } else {

  7081.             filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 );

  7082.             filter_mb_edgev( h, &img_y[4*1], linesize, bS3, qp );

  7083.             filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp );

  7084.             filter_mb_edgev( h, &img_y[4*3], linesize, bS3, qp );

  7085.             filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 );

  7086.             filter_mb_edgeh( h, &img_y[4*1*linesize], linesize, bS3, qp );

  7087.             filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp );

  7088.             filter_mb_edgeh( h, &img_y[4*3*linesize], linesize, bS3, qp );

  7089.         }

  7090.         filter_mb_edgecv( h, &img_cb[2*0], uvlinesize, bS4, qpc0 );

  7091.         filter_mb_edgecv( h, &img_cb[2*2], uvlinesize, bS3, qpc );

  7092.         filter_mb_edgecv( h, &img_cr[2*0], uvlinesize, bS4, qpc0 );

  7093.         filter_mb_edgecv( h, &img_cr[2*2], uvlinesize, bS3, qpc );

  7094.         filter_mb_edgech( h, &img_cb[2*0*uvlinesize], uvlinesize, bS4, qpc1 );

  7095.         filter_mb_edgech( h, &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc );

  7096.         filter_mb_edgech( h, &img_cr[2*0*uvlinesize], uvlinesize, bS4, qpc1 );

  7097.         filter_mb_edgech( h, &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc );

  7098.         return;

  7099.     } else {

  7100.         DECLARE_ALIGNED_8(int16_t, bS[2][4][4]);

  7101.         uint64_t (*bSv)[4] = (uint64_t(*)[4])bS;

  7102.         int edges;

  7103.         if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 ) {

  7104.             edges = 4;

  7105.             bSv[0][0] = bSv[0][2] = bSv[1][0] = bSv[1][2] = 0x0002000200020002ULL;

  7106.         } else {

  7107.             int mask_edge1 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 :

  7108.                              (mb_type & MB_TYPE_16x8) ? 1 : 0;

  7109.             int mask_edge0 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16))

  7110.                              && (s->current_picture.mb_type[mb_xy-1] & (MB_TYPE_16x16 | MB_TYPE_8x16))

  7111.                              ? 3 : 0;

  7112.             int step = IS_8x8DCT(mb_type) ? 2 : 1;

  7113.             edges = (mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4;

  7114.             s->dsp.h264_loop_filter_strength( bS, h->non_zero_count_cache, h->ref_cache, h->mv_cache,

  7115.                                               (h->slice_type == B_TYPE), edges, step, mask_edge0, mask_edge1 );

  7116.         }

  7117.         if( IS_INTRA(s->current_picture.mb_type[mb_xy-1]) )

  7118.             bSv[0][0] = 0x0004000400040004ULL;

  7119.         if( IS_INTRA(s->current_picture.mb_type[h->top_mb_xy]) )

  7120.             bSv[1][0] = 0x0004000400040004ULL;

  7121. 

  7122. #define FILTER(hv,dir,edge)\

  7123.         if(bSv[dir][edge]) {\

  7124.             filter_mb_edge##hv( h, &img_y[4*edge*(dir?linesize:1)], linesize, bS[dir][edge], edge ? qp : qp##dir );\

  7125.             if(!(edge&1)) {\

  7126.                 filter_mb_edgec##hv( h, &img_cb[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir );\

  7127.                 filter_mb_edgec##hv( h, &img_cr[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir );\

  7128.             }\

  7129.         }

  7130.         if( edges == 1 ) {

  7131.             FILTER(v,0,0);

  7132.             FILTER(h,1,0);

  7133.         } else if( IS_8x8DCT(mb_type) ) {

  7134.             FILTER(v,0,0);

  7135.             FILTER(v,0,2);

  7136.             FILTER(h,1,0);

  7137.             FILTER(h,1,2);

  7138.         } else {

  7139.             FILTER(v,0,0);

  7140.             FILTER(v,0,1);

  7141.             FILTER(v,0,2);

  7142.             FILTER(v,0,3);

  7143.             FILTER(h,1,0);

  7144.             FILTER(h,1,1);

  7145.             FILTER(h,1,2);

  7146.             FILTER(h,1,3);

  7147.         }

  7148. #undef FILTER

  7149.     }

  7150. }

  7151. 

  7152. static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize) {

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

  7154.     const int mb_xy= mb_x + mb_y*s->mb_stride;

  7155.     const int mb_type = s->current_picture.mb_type[mb_xy];

  7156.     const int mvy_limit = IS_INTERLACED(mb_type) ? 2 : 4;

  7157.     int first_vertical_edge_done = 0;

  7158.     int dir;

  7159.     /* FIXME: A given frame may occupy more than one position in

  7160.      * the reference list. So ref2frm should be populated with

  7161.      * frame numbers, not indices. */

  7162.     static const int ref2frm[34] = {-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,

  7163.                                     16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};

  7164. 

  7165.     //for sufficiently low qp, filtering wouldn't do anything

  7166.     //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp

  7167.     if(!FRAME_MBAFF){

  7168.         int qp_thresh = 15 - h->slice_alpha_c0_offset - FFMAX(0, h->pps.chroma_qp_index_offset);

  7169.         int qp = s->current_picture.qscale_table[mb_xy];

  7170.         if(qp <= qp_thresh

  7171.            && (mb_x == 0 || ((qp + s->current_picture.qscale_table[mb_xy-1] + 1)>>1) <= qp_thresh)

  7172.            && (mb_y == 0 || ((qp + s->current_picture.qscale_table[h->top_mb_xy] + 1)>>1) <= qp_thresh)){

  7173.             return;

  7174.         }

  7175.     }

  7176. 

  7177.     if (FRAME_MBAFF

  7178.             // left mb is in picture

  7179.             && h->slice_table[mb_xy-1] != 255

  7180.             // and current and left pair do not have the same interlaced type

  7181.             && (IS_INTERLACED(mb_type) != IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]))

  7182.             // and left mb is in the same slice if deblocking_filter == 2

  7183.             && (h->deblocking_filter!=2 || h->slice_table[mb_xy-1] == h->slice_table[mb_xy])) {

  7184.         /* First vertical edge is different in MBAFF frames

  7185.          * There are 8 different bS to compute and 2 different Qp

  7186.          */

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

  7188.         const int left_mb_xy[2] = { pair_xy-1, pair_xy-1+s->mb_stride };

  7189.         int16_t bS[8];

  7190.         int qp[2];

  7191.         int chroma_qp[2];

  7192.         int mb_qp, mbn0_qp, mbn1_qp;

  7193.         int i;

  7194.         first_vertical_edge_done = 1;

  7195. 

  7196.         if( IS_INTRA(mb_type) )

  7197.             bS[0] = bS[1] = bS[2] = bS[3] = bS[4] = bS[5] = bS[6] = bS[7] = 4;

  7198.         else {

  7199.             for( i = 0; i < 8; i++ ) {

  7200.                 int mbn_xy = MB_FIELD ? left_mb_xy[i>>2] : left_mb_xy[i&1];

  7201. 

  7202.                 if( IS_INTRA( s->current_picture.mb_type[mbn_xy] ) )

  7203.                     bS[i] = 4;

  7204.                 else if( h->non_zero_count_cache[12+8*(i>>1)] != 0 ||

  7205.                          /* FIXME: with 8x8dct + cavlc, should check cbp instead of nnz */

  7206.                          h->non_zero_count[mbn_xy][MB_FIELD ? i&3 : (i>>2)+(mb_y&1)*2] )

  7207.                     bS[i] = 2;

  7208.                 else

  7209.                     bS[i] = 1;

  7210.             }

  7211.         }

  7212. 

  7213.         mb_qp = s->current_picture.qscale_table[mb_xy];

  7214.         mbn0_qp = s->current_picture.qscale_table[left_mb_xy[0]];

  7215.         mbn1_qp = s->current_picture.qscale_table[left_mb_xy[1]];

  7216.         qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1;

  7217.         chroma_qp[0] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) +

  7218.                          get_chroma_qp( h->pps.chroma_qp_index_offset, mbn0_qp ) + 1 ) >> 1;

  7219.         qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1;

  7220.         chroma_qp[1] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) +

  7221.                          get_chroma_qp( h->pps.chroma_qp_index_offset, mbn1_qp ) + 1 ) >> 1;

  7222. 

  7223.         /* Filter edge */

  7224.         tprintf("filter mb:%d/%d MBAFF, QPy:%d/%d, QPc:%d/%d ls:%d uvls:%d", mb_x, mb_y, qp[0], qp[1], chroma_qp[0], chroma_qp[1], linesize, uvlinesize);

  7225.         { int i; for (i = 0; i < 8; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }

  7226.         filter_mb_mbaff_edgev ( h, &img_y [0], linesize,   bS, qp );

  7227.         filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, chroma_qp );

  7228.         filter_mb_mbaff_edgecv( h, &img_cr[0], uvlinesize, bS, chroma_qp );

  7229.     }

  7230.     /* dir : 0 -> vertical edge, 1 -> horizontal edge */

  7231.     for( dir = 0; dir < 2; dir++ )

  7232.     {

  7233.         int edge;

  7234.         const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy;

  7235.         const int mbm_type = s->current_picture.mb_type[mbm_xy];

  7236.         int start = h->slice_table[mbm_xy] == 255 ? 1 : 0;

  7237. 

  7238.         const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP))

  7239.                                   == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4;

  7240.         // how often to recheck mv-based bS when iterating between edges

  7241.         const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 :

  7242.                               (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0;

  7243.         // how often to recheck mv-based bS when iterating along each edge

  7244.         const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir));

  7245. 

  7246.         if (first_vertical_edge_done) {

  7247.             start = 1;

  7248.             first_vertical_edge_done = 0;

  7249.         }

  7250. 

  7251.         if (h->deblocking_filter==2 && h->slice_table[mbm_xy] != h->slice_table[mb_xy])

  7252.             start = 1;

  7253. 

  7254.         if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0

  7255.             && !IS_INTERLACED(mb_type)

  7256.             && IS_INTERLACED(mbm_type)

  7257.             ) {

  7258.             // This is a special case in the norm where the filtering must

  7259.             // be done twice (one each of the field) even if we are in a

  7260.             // frame macroblock.

  7261.             //

  7262.             static const int nnz_idx[4] = {4,5,6,3};

  7263.             unsigned int tmp_linesize   = 2 *   linesize;

  7264.             unsigned int tmp_uvlinesize = 2 * uvlinesize;

  7265.             int mbn_xy = mb_xy - 2 * s->mb_stride;

  7266.             int qp, chroma_qp;

  7267.             int i, j;

  7268.             int16_t bS[4];

  7269. 

  7270.             for(j=0; j<2; j++, mbn_xy += s->mb_stride){

  7271.                 if( IS_INTRA(mb_type) ||

  7272.                     IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) {

  7273.                     bS[0] = bS[1] = bS[2] = bS[3] = 3;

  7274.                 } else {

  7275.                     const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy];

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

  7277.                         if( h->non_zero_count_cache[scan8[0]+i] != 0 ||

  7278.                             mbn_nnz[nnz_idx[i]] != 0 )

  7279.                             bS[i] = 2;

  7280.                         else

  7281.                             bS[i] = 1;

  7282.                     }

  7283.                 }

  7284.                 // Do not use s->qscale as luma quantizer because it has not the same

  7285.                 // value in IPCM macroblocks.

  7286.                 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;

  7287.                 tprintf("filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, tmp_linesize, tmp_uvlinesize);

  7288.                 { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }

  7289.                 filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp );

  7290.                 chroma_qp = ( h->chroma_qp +

  7291.                               get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;

  7292.                 filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp );

  7293.                 filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp );

  7294.             }

  7295. 

  7296.             start = 1;

  7297.         }

  7298. 

  7299.         /* Calculate bS */

  7300.         for( edge = start; edge < edges; edge++ ) {

  7301.             /* mbn_xy: neighbor macroblock */

  7302.             const int mbn_xy = edge > 0 ? mb_xy : mbm_xy;

  7303.             const int mbn_type = s->current_picture.mb_type[mbn_xy];

  7304.             int16_t bS[4];

  7305.             int qp;

  7306. 

  7307.             if( (edge&1) && IS_8x8DCT(mb_type) )

  7308.                 continue;

  7309. 

  7310.             if( IS_INTRA(mb_type) ||

  7311.                 IS_INTRA(mbn_type) ) {

  7312.                 int value;

  7313.                 if (edge == 0) {

  7314.                     if (   (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type))

  7315.                         || ((FRAME_MBAFF || (s->picture_structure != PICT_FRAME)) && (dir == 0))

  7316.                     ) {

  7317.                         value = 4;

  7318.                     } else {

  7319.                         value = 3;

  7320.                     }

  7321.                 } else {

  7322.                     value = 3;

  7323.                 }

  7324.                 bS[0] = bS[1] = bS[2] = bS[3] = value;

  7325.             } else {

  7326.                 int i, l;

  7327.                 int mv_done;

  7328. 

  7329.                 if( edge & mask_edge ) {

  7330.                     bS[0] = bS[1] = bS[2] = bS[3] = 0;

  7331.                     mv_done = 1;

  7332.                 }

  7333.                 else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) {

  7334.                     bS[0] = bS[1] = bS[2] = bS[3] = 1;

  7335.                     mv_done = 1;

  7336.                 }

  7337.                 else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) {

  7338.                     int b_idx= 8 + 4 + edge * (dir ? 8:1);

  7339.                     int bn_idx= b_idx - (dir ? 8:1);

  7340.                     int v = 0;

  7341.                     for( l = 0; !v && l < 1 + (h->slice_type == B_TYPE); l++ ) {

  7342.                         v |= ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] ||

  7343.                              FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||

  7344.                              FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit;

  7345.                     }

  7346.                     bS[0] = bS[1] = bS[2] = bS[3] = v;

  7347.                     mv_done = 1;

  7348.                 }

  7349.                 else

  7350.                     mv_done = 0;

  7351. 

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

  7353.                     int x = dir == 0 ? edge : i;

  7354.                     int y = dir == 0 ? i    : edge;

  7355.                     int b_idx= 8 + 4 + x + 8*y;

  7356.                     int bn_idx= b_idx - (dir ? 8:1);

  7357. 

  7358.                     if( h->non_zero_count_cache[b_idx] != 0 ||

  7359.                         h->non_zero_count_cache[bn_idx] != 0 ) {

  7360.                         bS[i] = 2;

  7361.                     }

  7362.                     else if(!mv_done)

  7363.                     {

  7364.                         bS[i] = 0;

  7365.                         for( l = 0; l < 1 + (h->slice_type == B_TYPE); l++ ) {

  7366.                             if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] ||

  7367.                                 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||

  7368.                                 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) {

  7369.                                 bS[i] = 1;

  7370.                                 break;

  7371.                             }

  7372.                         }

  7373.                     }

  7374.                 }

  7375. 

  7376.                 if(bS[0]+bS[1]+bS[2]+bS[3] == 0)

  7377.                     continue;

  7378.             }

  7379. 

  7380.             /* Filter edge */

  7381.             // Do not use s->qscale as luma quantizer because it has not the same

  7382.             // value in IPCM macroblocks.

  7383.             qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;

  7384.             //tprintf("filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp, s->current_picture.qscale_table[mbn_xy]);

  7385.             tprintf("filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);

  7386.             { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }

  7387.             if( dir == 0 ) {

  7388.                 filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp );

  7389.                 if( (edge&1) == 0 ) {

  7390.                     int chroma_qp = ( h->chroma_qp +

  7391.                                       get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;

  7392.                     filter_mb_edgecv( h, &img_cb[2*edge], uvlinesize, bS, chroma_qp );

  7393.                     filter_mb_edgecv( h, &img_cr[2*edge], uvlinesize, bS, chroma_qp );

  7394.                 }

  7395.             } else {

  7396.                 filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp );

  7397.                 if( (edge&1) == 0 ) {

  7398.                     int chroma_qp = ( h->chroma_qp +

  7399.                                       get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;

  7400.                     filter_mb_edgech( h, &img_cb[2*edge*uvlinesize], uvlinesize, bS, chroma_qp );

  7401.                     filter_mb_edgech( h, &img_cr[2*edge*uvlinesize], uvlinesize, bS, chroma_qp );

  7402.                 }

  7403.             }

  7404.         }

  7405.     }

  7406. }

  7407. 

  7408. static int decode_slice(H264Context *h){

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

  7410.     const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;

  7411. 

  7412.     s->mb_skip_run= -1;

  7413. 

  7414.     if( h->pps.cabac ) {

  7415.         int i;

  7416. 

  7417.         /* realign */

  7418.         align_get_bits( &s->gb );

  7419. 

  7420.         /* init cabac */

  7421.         ff_init_cabac_states( &h->cabac);

  7422.         ff_init_cabac_decoder( &h->cabac,

  7423.                                s->gb.buffer + get_bits_count(&s->gb)/8,

  7424.                                ( s->gb.size_in_bits - get_bits_count(&s->gb) + 7)/8);

  7425.         /* calculate pre-state */

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

  7427.             int pre;

  7428.             if( h->slice_type == I_TYPE )

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

  7430.             else

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

  7432. 

  7433.             if( pre <= 63 )

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

  7435.             else

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

  7437.         }

  7438. 

  7439.         for(;;){

  7440. //START_TIMER

  7441.             int ret = decode_mb_cabac(h);

  7442.             int eos;

  7443. //STOP_TIMER("decode_mb_cabac")

  7444. 

  7445.             if(ret>=0) hl_decode_mb(h);

  7446. 

  7447.             if( ret >= 0 && FRAME_MBAFF ) { //FIXME optimal? or let mb_decode decode 16x32 ?

  7448.                 s->mb_y++;

  7449. 

  7450.                 if(ret>=0) ret = decode_mb_cabac(h);

  7451. 

  7452.                 if(ret>=0) hl_decode_mb(h);

  7453.                 s->mb_y--;

  7454.             }

  7455.             eos = get_cabac_terminate( &h->cabac );

  7456. 

  7457.             if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 2) {

  7458.                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d, bytestream (%d)\n", s->mb_x, s->mb_y, h->cabac.bytestream_end - h->cabac.bytestream);

  7459.                 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);

  7460.                 return -1;

  7461.             }

  7462. 

  7463.             if( ++s->mb_x >= s->mb_width ) {

  7464.                 s->mb_x = 0;

  7465.                 ff_draw_horiz_band(s, 16*s->mb_y, 16);

  7466.                 ++s->mb_y;

  7467.                 if(FRAME_MBAFF) {

  7468.                     ++s->mb_y;

  7469.                 }

  7470.             }

  7471. 

  7472.             if( eos || s->mb_y >= s->mb_height ) {

  7473.                 tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);

  7474.                 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

  7475.                 return 0;

  7476.             }

  7477.         }

  7478. 

  7479.     } else {

  7480.         for(;;){

  7481.             int ret = decode_mb_cavlc(h);

  7482. 

  7483.             if(ret>=0) hl_decode_mb(h);

  7484. 

  7485.             if(ret>=0 && FRAME_MBAFF){ //FIXME optimal? or let mb_decode decode 16x32 ?

  7486.                 s->mb_y++;

  7487.                 ret = decode_mb_cavlc(h);

  7488. 

  7489.                 if(ret>=0) hl_decode_mb(h);

  7490.                 s->mb_y--;

  7491.             }

  7492. 

  7493.             if(ret<0){

  7494.                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);

  7495.                 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);

  7496. 

  7497.                 return -1;

  7498.             }

  7499. 

  7500.             if(++s->mb_x >= s->mb_width){

  7501.                 s->mb_x=0;

  7502.                 ff_draw_horiz_band(s, 16*s->mb_y, 16);

  7503.                 ++s->mb_y;

  7504.                 if(FRAME_MBAFF) {

  7505.                     ++s->mb_y;

  7506.                 }

  7507.                 if(s->mb_y >= s->mb_height){

  7508.                     tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);

  7509. 

  7510.                     if(get_bits_count(&s->gb) == s->gb.size_in_bits ) {

  7511.                         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

  7512. 

  7513.                         return 0;

  7514.                     }else{

  7515.                         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

  7516. 

  7517.                         return -1;

  7518.                     }

  7519.                 }

  7520.             }

  7521. 

  7522.             if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){

  7523.                 tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);

  7524.                 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){

  7525.                     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

  7526. 

  7527.                     return 0;

  7528.                 }else{

  7529.                     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);

  7530. 

  7531.                     return -1;

  7532.                 }

  7533.             }

  7534.         }

  7535.     }

  7536. 

  7537. #if 0

  7538.     for(;s->mb_y < s->mb_height; s->mb_y++){

  7539.         for(;s->mb_x < s->mb_width; s->mb_x++){

  7540.             int ret= decode_mb(h);

  7541. 

  7542.             hl_decode_mb(h);

  7543. 

  7544.             if(ret<0){

  7545.                 av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);

  7546.                 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);

  7547. 

  7548.                 return -1;

  7549.             }

  7550. 

  7551.             if(++s->mb_x >= s->mb_width){

  7552.                 s->mb_x=0;

  7553.                 if(++s->mb_y >= s->mb_height){

  7554.                     if(get_bits_count(s->gb) == s->gb.size_in_bits){

  7555.                         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

  7556. 

  7557.                         return 0;

  7558.                     }else{

  7559.                         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

  7560. 

  7561.                         return -1;

  7562.                     }

  7563.                 }

  7564.             }

  7565. 

  7566.             if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){

  7567.                 if(get_bits_count(s->gb) == s->gb.size_in_bits){

  7568.                     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

  7569. 

  7570.                     return 0;

  7571.                 }else{

  7572.                     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);

  7573. 

  7574.                     return -1;

  7575.                 }

  7576.             }

  7577.         }

  7578.         s->mb_x=0;

  7579.         ff_draw_horiz_band(s, 16*s->mb_y, 16);

  7580.     }

  7581. #endif

  7582.     return -1; //not reached

  7583. }

  7584. 

  7585. static int decode_unregistered_user_data(H264Context *h, int size){

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

  7587.     uint8_t user_data[16+256];

  7588.     int e, build, i;

  7589. 

  7590.     if(size<16)

  7591.         return -1;

  7592. 

  7593.     for(i=0; i<sizeof(user_data)-1 && i<size; i++){

  7594.         user_data[i]= get_bits(&s->gb, 8);

  7595.     }

  7596. 

  7597.     user_data[i]= 0;

  7598.     e= sscanf(user_data+16, "x264 - core %d"/*%s - H.264/MPEG-4 AVC codec - Copyleft 2005 - http://www.videolan.org/x264.html*/, &build);

  7599.     if(e==1 && build>=0)

  7600.         h->x264_build= build;

  7601. 

  7602.     if(s->avctx->debug & FF_DEBUG_BUGS)

  7603.         av_log(s->avctx, AV_LOG_DEBUG, "user data:\"%s\"\n", user_data+16);

  7604. 

  7605.     for(; i<size; i++)

  7606.         skip_bits(&s->gb, 8);

  7607. 

  7608.     return 0;

  7609. }

  7610. 

  7611. static int decode_sei(H264Context *h){

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

  7613. 

  7614.     while(get_bits_count(&s->gb) + 16 < s->gb.size_in_bits){

  7615.         int size, type;

  7616. 

  7617.         type=0;

  7618.         do{

  7619.             type+= show_bits(&s->gb, 8);

  7620.         }while(get_bits(&s->gb, 8) == 255);

  7621. 

  7622.         size=0;

  7623.         do{

  7624.             size+= show_bits(&s->gb, 8);

  7625.         }while(get_bits(&s->gb, 8) == 255);

  7626. 

  7627.         switch(type){

  7628.         case 5:

  7629.             if(decode_unregistered_user_data(h, size) < 0)

  7630.                 return -1;

  7631.             break;

  7632.         default:

  7633.             skip_bits(&s->gb, 8*size);

  7634.         }

  7635. 

  7636.         //FIXME check bits here

  7637.         align_get_bits(&s->gb);

  7638.     }

  7639. 

  7640.     return 0;

  7641. }

  7642. 

  7643. static inline void decode_hrd_parameters(H264Context *h, SPS *sps){

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

  7645.     int cpb_count, i;

  7646.     cpb_count = get_ue_golomb(&s->gb) + 1;

  7647.     get_bits(&s->gb, 4); /* bit_rate_scale */

  7648.     get_bits(&s->gb, 4); /* cpb_size_scale */

  7649.     for(i=0; i<cpb_count; i++){

  7650.         get_ue_golomb(&s->gb); /* bit_rate_value_minus1 */

  7651.         get_ue_golomb(&s->gb); /* cpb_size_value_minus1 */

  7652.         get_bits1(&s->gb);     /* cbr_flag */

  7653.     }

  7654.     get_bits(&s->gb, 5); /* initial_cpb_removal_delay_length_minus1 */

  7655.     get_bits(&s->gb, 5); /* cpb_removal_delay_length_minus1 */

  7656.     get_bits(&s->gb, 5); /* dpb_output_delay_length_minus1 */

  7657.     get_bits(&s->gb, 5); /* time_offset_length */

  7658. }

  7659. 

  7660. static inline int decode_vui_parameters(H264Context *h, SPS *sps){

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

  7662.     int aspect_ratio_info_present_flag, aspect_ratio_idc;

  7663.     int nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag;

  7664. 

  7665.     aspect_ratio_info_present_flag= get_bits1(&s->gb);

  7666. 

  7667.     if( aspect_ratio_info_present_flag ) {

  7668.         aspect_ratio_idc= get_bits(&s->gb, 8);

  7669.         if( aspect_ratio_idc == EXTENDED_SAR ) {

  7670.             sps->sar.num= get_bits(&s->gb, 16);

  7671.             sps->sar.den= get_bits(&s->gb, 16);

  7672.         }else if(aspect_ratio_idc < 14){

  7673.             sps->sar=  pixel_aspect[aspect_ratio_idc];

  7674.         }else{

  7675.             av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");

  7676.             return -1;

  7677.         }

  7678.     }else{

  7679.         sps->sar.num=

  7680.         sps->sar.den= 0;

  7681.     }

  7682. //            s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);

  7683. 

  7684.     if(get_bits1(&s->gb)){      /* overscan_info_present_flag */

  7685.         get_bits1(&s->gb);      /* overscan_appropriate_flag */

  7686.     }

  7687. 

  7688.     if(get_bits1(&s->gb)){      /* video_signal_type_present_flag */

  7689.         get_bits(&s->gb, 3);    /* video_format */

  7690.         get_bits1(&s->gb);      /* video_full_range_flag */

  7691.         if(get_bits1(&s->gb)){  /* colour_description_present_flag */

  7692.             get_bits(&s->gb, 8); /* colour_primaries */

  7693.             get_bits(&s->gb, 8); /* transfer_characteristics */

  7694.             get_bits(&s->gb, 8); /* matrix_coefficients */

  7695.         }

  7696.     }

  7697. 

  7698.     if(get_bits1(&s->gb)){      /* chroma_location_info_present_flag */

  7699.         get_ue_golomb(&s->gb);  /* chroma_sample_location_type_top_field */

  7700.         get_ue_golomb(&s->gb);  /* chroma_sample_location_type_bottom_field */

  7701.     }

  7702. 

  7703.     sps->timing_info_present_flag = get_bits1(&s->gb);

  7704.     if(sps->timing_info_present_flag){

  7705.         sps->num_units_in_tick = get_bits_long(&s->gb, 32);

  7706.         sps->time_scale = get_bits_long(&s->gb, 32);

  7707.         sps->fixed_frame_rate_flag = get_bits1(&s->gb);

  7708.     }

  7709. 

  7710.     nal_hrd_parameters_present_flag = get_bits1(&s->gb);

  7711.     if(nal_hrd_parameters_present_flag)

  7712.         decode_hrd_parameters(h, sps);

  7713.     vcl_hrd_parameters_present_flag = get_bits1(&s->gb);

  7714.     if(vcl_hrd_parameters_present_flag)

  7715.         decode_hrd_parameters(h, sps);

  7716.     if(nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag)

  7717.         get_bits1(&s->gb);     /* low_delay_hrd_flag */

  7718.     get_bits1(&s->gb);         /* pic_struct_present_flag */

  7719. 

  7720.     sps->bitstream_restriction_flag = get_bits1(&s->gb);

  7721.     if(sps->bitstream_restriction_flag){

  7722.         get_bits1(&s->gb);     /* motion_vectors_over_pic_boundaries_flag */

  7723.         get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */

  7724.         get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */

  7725.         get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */

  7726.         get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */

  7727.         sps->num_reorder_frames = get_ue_golomb(&s->gb);

  7728.         get_ue_golomb(&s->gb); /* max_dec_frame_buffering */

  7729.     }

  7730. 

  7731.     return 0;

  7732. }

  7733. 

  7734. static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,

  7735.                                 const uint8_t *jvt_list, const uint8_t *fallback_list){

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

  7737.     int i, last = 8, next = 8;

  7738.     const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8;

  7739.     if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */

  7740.         memcpy(factors, fallback_list, size*sizeof(uint8_t));

  7741.     else

  7742.     for(i=0;i<size;i++){

  7743.         if(next)

  7744.             next = (last + get_se_golomb(&s->gb)) & 0xff;

  7745.         if(!i && !next){ /* matrix not written, we use the preset one */

  7746.             memcpy(factors, jvt_list, size*sizeof(uint8_t));

  7747.             break;

  7748.         }

  7749.         last = factors[scan[i]] = next ? next : last;

  7750.     }

  7751. }

  7752. 

  7753. static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,

  7754.                                    uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){

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

  7756.     int fallback_sps = !is_sps && sps->scaling_matrix_present;

  7757.     const uint8_t *fallback[4] = {

  7758.         fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],

  7759.         fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],

  7760.         fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],

  7761.         fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1]

  7762.     };

  7763.     if(get_bits1(&s->gb)){

  7764.         sps->scaling_matrix_present |= is_sps;

  7765.         decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y

  7766.         decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr

  7767.         decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb

  7768.         decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y

  7769.         decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr

  7770.         decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb

  7771.         if(is_sps || pps->transform_8x8_mode){

  7772.             decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]);  // Intra, Y

  7773.             decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]);  // Inter, Y

  7774.         }

  7775.     } else if(fallback_sps) {

  7776.         memcpy(scaling_matrix4, sps->scaling_matrix4, 6*16*sizeof(uint8_t));

  7777.         memcpy(scaling_matrix8, sps->scaling_matrix8, 2*64*sizeof(uint8_t));

  7778.     }

  7779. }

  7780. 

  7781. static inline int decode_seq_parameter_set(H264Context *h){

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

  7783.     int profile_idc, level_idc;

  7784.     int sps_id, i;

  7785.     SPS *sps;

  7786. 

  7787.     profile_idc= get_bits(&s->gb, 8);

  7788.     get_bits1(&s->gb);   //constraint_set0_flag

  7789.     get_bits1(&s->gb);   //constraint_set1_flag

  7790.     get_bits1(&s->gb);   //constraint_set2_flag

  7791.     get_bits1(&s->gb);   //constraint_set3_flag

  7792.     get_bits(&s->gb, 4); // reserved

  7793.     level_idc= get_bits(&s->gb, 8);

  7794.     sps_id= get_ue_golomb(&s->gb);

  7795. 

  7796.     sps= &h->sps_buffer[ sps_id ];

  7797.     sps->profile_idc= profile_idc;

  7798.     sps->level_idc= level_idc;

  7799. 

  7800.     if(sps->profile_idc >= 100){ //high profile

  7801.         if(get_ue_golomb(&s->gb) == 3) //chroma_format_idc

  7802.             get_bits1(&s->gb);  //residual_color_transform_flag

  7803.         get_ue_golomb(&s->gb);  //bit_depth_luma_minus8

  7804.         get_ue_golomb(&s->gb);  //bit_depth_chroma_minus8

  7805.         sps->transform_bypass = get_bits1(&s->gb);

  7806.         decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);

  7807.     }else

  7808.         sps->scaling_matrix_present = 0;

  7809. 

  7810.     sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;

  7811.     sps->poc_type= get_ue_golomb(&s->gb);

  7812. 

  7813.     if(sps->poc_type == 0){ //FIXME #define

  7814.         sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;

  7815.     } else if(sps->poc_type == 1){//FIXME #define

  7816.         sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);

  7817.         sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);

  7818.         sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);

  7819.         sps->poc_cycle_length= get_ue_golomb(&s->gb);

  7820. 

  7821.         for(i=0; i<sps->poc_cycle_length; i++)

  7822.             sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);

  7823.     }

  7824.     if(sps->poc_type > 2){

  7825.         av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);

  7826.         return -1;

  7827.     }

  7828. 

  7829.     sps->ref_frame_count= get_ue_golomb(&s->gb);

  7830.     if(sps->ref_frame_count > MAX_PICTURE_COUNT-2){

  7831.         av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");

  7832.     }

  7833.     sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);

  7834.     sps->mb_width= get_ue_golomb(&s->gb) + 1;

  7835.     sps->mb_height= get_ue_golomb(&s->gb) + 1;

  7836.     if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||

  7837.        avcodec_check_dimensions(NULL, 16*sps->mb_width, 16*sps->mb_height))

  7838.         return -1;

  7839. 

  7840.     sps->frame_mbs_only_flag= get_bits1(&s->gb);

  7841.     if(!sps->frame_mbs_only_flag)

  7842.         sps->mb_aff= get_bits1(&s->gb);

  7843.     else

  7844.         sps->mb_aff= 0;

  7845. 

  7846.     sps->direct_8x8_inference_flag= get_bits1(&s->gb);

  7847. 

  7848. #ifndef ALLOW_INTERLACE

  7849.     if(sps->mb_aff)

  7850.         av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");

  7851. #endif

  7852.     if(!sps->direct_8x8_inference_flag && sps->mb_aff)

  7853.         av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + !direct_8x8_inference is not implemented\n");

  7854. 

  7855.     sps->crop= get_bits1(&s->gb);

  7856.     if(sps->crop){

  7857.         sps->crop_left  = get_ue_golomb(&s->gb);

  7858.         sps->crop_right = get_ue_golomb(&s->gb);

  7859.         sps->crop_top   = get_ue_golomb(&s->gb);

  7860.         sps->crop_bottom= get_ue_golomb(&s->gb);

  7861.         if(sps->crop_left || sps->crop_top){

  7862.             av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");

  7863.         }

  7864.     }else{

  7865.         sps->crop_left  =

  7866.         sps->crop_right =

  7867.         sps->crop_top   =

  7868.         sps->crop_bottom= 0;

  7869.     }

  7870. 

  7871.     sps->vui_parameters_present_flag= get_bits1(&s->gb);

  7872.     if( sps->vui_parameters_present_flag )

  7873.         decode_vui_parameters(h, sps);

  7874. 

  7875.     if(s->avctx->debug&FF_DEBUG_PICT_INFO){

  7876.         av_log(h->s.avctx, AV_LOG_DEBUG, "sps:%d profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s\n",

  7877.                sps_id, sps->profile_idc, sps->level_idc,

  7878.                sps->poc_type,

  7879.                sps->ref_frame_count,

  7880.                sps->mb_width, sps->mb_height,

  7881.                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),

  7882.                sps->direct_8x8_inference_flag ? "8B8" : "",

  7883.                sps->crop_left, sps->crop_right,

  7884.                sps->crop_top, sps->crop_bottom,

  7885.                sps->vui_parameters_present_flag ? "VUI" : ""

  7886.                );

  7887.     }

  7888.     return 0;

  7889. }

  7890. 

  7891. static inline int decode_picture_parameter_set(H264Context *h, int bit_length){

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

  7893.     int pps_id= get_ue_golomb(&s->gb);

  7894.     PPS *pps= &h->pps_buffer[pps_id];

  7895. 

  7896.     pps->sps_id= get_ue_golomb(&s->gb);

  7897.     pps->cabac= get_bits1(&s->gb);

  7898.     pps->pic_order_present= get_bits1(&s->gb);

  7899.     pps->slice_group_count= get_ue_golomb(&s->gb) + 1;

  7900.     if(pps->slice_group_count > 1 ){

  7901.         pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);

  7902.         av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");

  7903.         switch(pps->mb_slice_group_map_type){

  7904.         case 0:

  7905. #if 0

  7906. |   for( i = 0; i <= num_slice_groups_minus1; i++ ) |   |        |

  7907. |    run_length[ i ]                                |1  |ue(v)   |

  7908. #endif

  7909.             break;

  7910.         case 2:

  7911. #if 0

  7912. |   for( i = 0; i < num_slice_groups_minus1; i++ )  |   |        |

  7913. |{                                                  |   |        |

  7914. |    top_left_mb[ i ]                               |1  |ue(v)   |

  7915. |    bottom_right_mb[ i ]                           |1  |ue(v)   |

  7916. |   }                                               |   |        |

  7917. #endif

  7918.             break;

  7919.         case 3:

  7920.         case 4:

  7921.         case 5:

  7922. #if 0

  7923. |   slice_group_change_direction_flag               |1  |u(1)    |

  7924. |   slice_group_change_rate_minus1                  |1  |ue(v)   |

  7925. #endif

  7926.             break;

  7927.         case 6:

  7928. #if 0

  7929. |   slice_group_id_cnt_minus1                       |1  |ue(v)   |

  7930. |   for( i = 0; i <= slice_group_id_cnt_minus1; i++ |   |        |

  7931. |)                                                  |   |        |

  7932. |    slice_group_id[ i ]                            |1  |u(v)    |

  7933. #endif

  7934.             break;

  7935.         }

  7936.     }

  7937.     pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;

  7938.     pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;

  7939.     if(pps->ref_count[0] > 32 || pps->ref_count[1] > 32){

  7940.         av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");

  7941.         return -1;

  7942.     }

  7943. 

  7944.     pps->weighted_pred= get_bits1(&s->gb);

  7945.     pps->weighted_bipred_idc= get_bits(&s->gb, 2);

  7946.     pps->init_qp= get_se_golomb(&s->gb) + 26;

  7947.     pps->init_qs= get_se_golomb(&s->gb) + 26;

  7948.     pps->chroma_qp_index_offset= get_se_golomb(&s->gb);

  7949.     pps->deblocking_filter_parameters_present= get_bits1(&s->gb);

  7950.     pps->constrained_intra_pred= get_bits1(&s->gb);

  7951.     pps->redundant_pic_cnt_present = get_bits1(&s->gb);

  7952. 

  7953.     pps->transform_8x8_mode= 0;

  7954.     h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit

  7955.     memset(pps->scaling_matrix4, 16, 6*16*sizeof(uint8_t));

  7956.     memset(pps->scaling_matrix8, 16, 2*64*sizeof(uint8_t));

  7957. 

  7958.     if(get_bits_count(&s->gb) < bit_length){

  7959.         pps->transform_8x8_mode= get_bits1(&s->gb);

  7960.         decode_scaling_matrices(h, &h->sps_buffer[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);

  7961.         get_se_golomb(&s->gb);  //second_chroma_qp_index_offset

  7962.     }

  7963. 

  7964.     if(s->avctx->debug&FF_DEBUG_PICT_INFO){

  7965.         av_log(h->s.avctx, AV_LOG_DEBUG, "pps:%d sps:%d %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d %s %s %s %s\n",

  7966.                pps_id, pps->sps_id,

  7967.                pps->cabac ? "CABAC" : "CAVLC",

  7968.                pps->slice_group_count,

  7969.                pps->ref_count[0], pps->ref_count[1],

  7970.                pps->weighted_pred ? "weighted" : "",

  7971.                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset,

  7972.                pps->deblocking_filter_parameters_present ? "LPAR" : "",

  7973.                pps->constrained_intra_pred ? "CONSTR" : "",

  7974.                pps->redundant_pic_cnt_present ? "REDU" : "",

  7975.                pps->transform_8x8_mode ? "8x8DCT" : ""

  7976.                );

  7977.     }

  7978. 

  7979.     return 0;

  7980. }

  7981. 

  7982. /**

  7983.  * finds the end of the current frame in the bitstream.

  7984.  * @return the position of the first byte of the next frame, or -1

  7985.  */

  7986. static int find_frame_end(H264Context *h, const uint8_t *buf, int buf_size){

  7987.     int i;

  7988.     uint32_t state;

  7989.     ParseContext *pc = &(h->s.parse_context);

  7990. //printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]);

  7991. //    mb_addr= pc->mb_addr - 1;

  7992.     state= pc->state;

  7993.     for(i=0; i<=buf_size; i++){

  7994.         if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){

  7995.             tprintf("find_frame_end new startcode = %08x, frame_start_found = %d, pos = %d\n", state, pc->frame_start_found, i);

  7996.             if(pc->frame_start_found){

  7997.                 // If there isn't one more byte in the buffer

  7998.                 // the test on first_mb_in_slice cannot be done yet

  7999.                 // do it at next call.

  8000.                 if (i >= buf_size) break;

  8001.                 if (buf[i] & 0x80) {

  8002.                     // first_mb_in_slice is 0, probably the first nal of a new

  8003.                     // slice

  8004.                     tprintf("find_frame_end frame_end_found, state = %08x, pos = %d\n", state, i);

  8005.                     pc->state=-1;

  8006.                     pc->frame_start_found= 0;

  8007.                     return i-4;

  8008.                 }

  8009.             }

  8010.             pc->frame_start_found = 1;

  8011.         }

  8012.         if((state&0xFFFFFF1F) == 0x107 || (state&0xFFFFFF1F) == 0x108 || (state&0xFFFFFF1F) == 0x109){

  8013.            if(pc->frame_start_found){

  8014.                 pc->state=-1;

  8015.                 pc->frame_start_found= 0;

  8016.                 return i-4;

  8017.            }

  8018.         }

  8019.         if (i<buf_size)

  8020.             state= (state<<8) | buf[i];

  8021.     }

  8022. 

  8023.     pc->state= state;

  8024.     return END_NOT_FOUND;

  8025. }

  8026. 

  8027. #ifdef CONFIG_H264_PARSER

  8028. static int h264_parse(AVCodecParserContext *s,

  8029.                       AVCodecContext *avctx,

  8030.                       uint8_t **poutbuf, int *poutbuf_size,

  8031.                       const uint8_t *buf, int buf_size)

  8032. {

  8033.     H264Context *h = s->priv_data;

  8034.     ParseContext *pc = &h->s.parse_context;

  8035.     int next;

  8036. 

  8037.     next= find_frame_end(h, buf, buf_size);

  8038. 

  8039.     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {

  8040.         *poutbuf = NULL;

  8041.         *poutbuf_size = 0;

  8042.         return buf_size;

  8043.     }

  8044. 

  8045.     *poutbuf = (uint8_t *)buf;

  8046.     *poutbuf_size = buf_size;

  8047.     return next;

  8048. }

  8049. 

  8050. static int h264_split(AVCodecContext *avctx,

  8051.                       const uint8_t *buf, int buf_size)

  8052. {

  8053.     int i;

  8054.     uint32_t state = -1;

  8055.     int has_sps= 0;

  8056. 

  8057.     for(i=0; i<=buf_size; i++){

  8058.         if((state&0xFFFFFF1F) == 0x107)

  8059.             has_sps=1;

  8060. /*        if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){

  8061.         }*/

  8062.         if((state&0xFFFFFF00) == 0x100 && (state&0xFFFFFF1F) != 0x107 && (state&0xFFFFFF1F) != 0x108 && (state&0xFFFFFF1F) != 0x109){

  8063.             if(has_sps){

  8064.                 while(i>4 && buf[i-5]==0) i--;

  8065.                 return i-4;

  8066.             }

  8067.         }

  8068.         if (i<buf_size)

  8069.             state= (state<<8) | buf[i];

  8070.     }

  8071.     return 0;

  8072. }

  8073. #endif /* CONFIG_H264_PARSER */

  8074. 

  8075. static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){

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

  8077.     AVCodecContext * const avctx= s->avctx;

  8078.     int buf_index=0;

  8079. #if 0

  8080.     int i;

  8081.     for(i=0; i<50; i++){

  8082.         av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]);

  8083.     }

  8084. #endif

  8085.     h->slice_num = 0;

  8086.     s->current_picture_ptr= NULL;

  8087.     for(;;){

  8088.         int consumed;

  8089.         int dst_length;

  8090.         int bit_length;

  8091.         uint8_t *ptr;

  8092.         int i, nalsize = 0;

  8093. 

  8094.       if(h->is_avc) {

  8095.         if(buf_index >= buf_size) break;

  8096.         nalsize = 0;

  8097.         for(i = 0; i < h->nal_length_size; i++)

  8098.             nalsize = (nalsize << 8) | buf[buf_index++];

  8099.         if(nalsize <= 1){

  8100.             if(nalsize == 1){

  8101.                 buf_index++;

  8102.                 continue;

  8103.             }else{

  8104.                 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize);

  8105.                 break;

  8106.             }

  8107.         }

  8108.       } else {

  8109.         // start code prefix search

  8110.         for(; buf_index + 3 < buf_size; buf_index++){

  8111.             // this should allways succeed in the first iteration

  8112.             if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1)

  8113.                 break;

  8114.         }

  8115. 

  8116.         if(buf_index+3 >= buf_size) break;

  8117. 

  8118.         buf_index+=3;

  8119.       }

  8120. 

  8121.         ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index);

  8122.         while(ptr[dst_length - 1] == 0 && dst_length > 1)

  8123.             dst_length--;

  8124.         bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1);

  8125. 

  8126.         if(s->avctx->debug&FF_DEBUG_STARTCODE){

  8127.             av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d/%d length %d\n", h->nal_unit_type, buf_index, buf_size, dst_length);

  8128.         }

  8129. 

  8130.         if (h->is_avc && (nalsize != consumed))

  8131.             av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize);

  8132. 

  8133.         buf_index += consumed;

  8134. 

  8135.         if(  (s->hurry_up == 1 && h->nal_ref_idc  == 0) //FIXME dont discard SEI id

  8136.            ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc  == 0))

  8137.             continue;

  8138. 

  8139.         switch(h->nal_unit_type){

  8140.         case NAL_IDR_SLICE:

  8141.             idr(h); //FIXME ensure we don't loose some frames if there is reordering

  8142.         case NAL_SLICE:

  8143.             init_get_bits(&s->gb, ptr, bit_length);

  8144.             h->intra_gb_ptr=

  8145.             h->inter_gb_ptr= &s->gb;

  8146.             s->data_partitioning = 0;

  8147. 

  8148.             if(decode_slice_header(h) < 0){

  8149.                 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");

  8150.                 break;

  8151.             }

  8152.             s->current_picture_ptr->key_frame= (h->nal_unit_type == NAL_IDR_SLICE);

  8153.             if(h->redundant_pic_count==0 && s->hurry_up < 5

  8154.                && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc)

  8155.                && (avctx->skip_frame < AVDISCARD_BIDIR  || h->slice_type!=B_TYPE)

  8156.                && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE)

  8157.                && avctx->skip_frame < AVDISCARD_ALL)

  8158.                 decode_slice(h);

  8159.             break;

  8160.         case NAL_DPA:

  8161.             init_get_bits(&s->gb, ptr, bit_length);

  8162.             h->intra_gb_ptr=

  8163.             h->inter_gb_ptr= NULL;

  8164.             s->data_partitioning = 1;

  8165. 

  8166.             if(decode_slice_header(h) < 0){

  8167.                 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");

  8168.             }

  8169.             break;

  8170.         case NAL_DPB:

  8171.             init_get_bits(&h->intra_gb, ptr, bit_length);

  8172.             h->intra_gb_ptr= &h->intra_gb;

  8173.             break;

  8174.         case NAL_DPC:

  8175.             init_get_bits(&h->inter_gb, ptr, bit_length);

  8176.             h->inter_gb_ptr= &h->inter_gb;

  8177. 

  8178.             if(h->redundant_pic_count==0 && h->intra_gb_ptr && s->data_partitioning

  8179.                && s->hurry_up < 5

  8180.                && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc)

  8181.                && (avctx->skip_frame < AVDISCARD_BIDIR  || h->slice_type!=B_TYPE)

  8182.                && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE)

  8183.                && avctx->skip_frame < AVDISCARD_ALL)

  8184.                 decode_slice(h);

  8185.             break;

  8186.         case NAL_SEI:

  8187.             init_get_bits(&s->gb, ptr, bit_length);

  8188.             decode_sei(h);

  8189.             break;

  8190.         case NAL_SPS:

  8191.             init_get_bits(&s->gb, ptr, bit_length);

  8192.             decode_seq_parameter_set(h);

  8193. 

  8194.             if(s->flags& CODEC_FLAG_LOW_DELAY)

  8195.                 s->low_delay=1;

  8196. 

  8197.             if(avctx->has_b_frames < 2)

  8198.                 avctx->has_b_frames= !s->low_delay;

  8199.             break;

  8200.         case NAL_PPS:

  8201.             init_get_bits(&s->gb, ptr, bit_length);

  8202. 

  8203.             decode_picture_parameter_set(h, bit_length);

  8204. 

  8205.             break;

  8206.         case NAL_AUD:

  8207.         case NAL_END_SEQUENCE:

  8208.         case NAL_END_STREAM:

  8209.         case NAL_FILLER_DATA:

  8210.         case NAL_SPS_EXT:

  8211.         case NAL_AUXILIARY_SLICE:

  8212.             break;

  8213.         default:

  8214.             av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type);

  8215.         }

  8216.     }

  8217. 

  8218.     if(!s->current_picture_ptr) return buf_index; //no frame

  8219. 

  8220.     s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;

  8221.     s->current_picture_ptr->pict_type= s->pict_type;

  8222. 

  8223.     h->prev_frame_num_offset= h->frame_num_offset;

  8224.     h->prev_frame_num= h->frame_num;

  8225.     if(s->current_picture_ptr->reference){

  8226.         h->prev_poc_msb= h->poc_msb;

  8227.         h->prev_poc_lsb= h->poc_lsb;

  8228.     }

  8229.     if(s->current_picture_ptr->reference)

  8230.         execute_ref_pic_marking(h, h->mmco, h->mmco_index);

  8231. 

  8232.     ff_er_frame_end(s);

  8233. 

  8234.     MPV_frame_end(s);

  8235. 

  8236.     return buf_index;

  8237. }

  8238. 

  8239. /**

  8240.  * returns the number of bytes consumed for building the current frame

  8241.  */

  8242. static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){

  8243.     if(s->flags&CODEC_FLAG_TRUNCATED){

  8244.         pos -= s->parse_context.last_index;

  8245.         if(pos<0) pos=0; // FIXME remove (unneeded?)

  8246. 

  8247.         return pos;

  8248.     }else{

  8249.         if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)

  8250.         if(pos+10>buf_size) pos=buf_size; // oops ;)

  8251. 

  8252.         return pos;

  8253.     }

  8254. }

  8255. 

  8256. static int decode_frame(AVCodecContext *avctx,

  8257.                              void *data, int *data_size,

  8258.                              uint8_t *buf, int buf_size)

  8259. {

  8260.     H264Context *h = avctx->priv_data;

  8261.     MpegEncContext *s = &h->s;

  8262.     AVFrame *pict = data;

  8263.     int buf_index;

  8264. 

  8265.     s->flags= avctx->flags;

  8266.     s->flags2= avctx->flags2;

  8267. 

  8268.    /* no supplementary picture */

  8269.     if (buf_size == 0) {

  8270.         return 0;

  8271.     }

  8272. 

  8273.     if(s->flags&CODEC_FLAG_TRUNCATED){

  8274.         int next= find_frame_end(h, buf, buf_size);

  8275. 

  8276.         if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 )

  8277.             return buf_size;

  8278. //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index);

  8279.     }

  8280. 

  8281.     if(h->is_avc && !h->got_avcC) {

  8282.         int i, cnt, nalsize;

  8283.         unsigned char *p = avctx->extradata;

  8284.         if(avctx->extradata_size < 7) {

  8285.             av_log(avctx, AV_LOG_ERROR, "avcC too short\n");

  8286.             return -1;

  8287.         }

  8288.         if(*p != 1) {

  8289.             av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p);

  8290.             return -1;

  8291.         }

  8292.         /* sps and pps in the avcC always have length coded with 2 bytes,

  8293.            so put a fake nal_length_size = 2 while parsing them */

  8294.         h->nal_length_size = 2;

  8295.         // Decode sps from avcC

  8296.         cnt = *(p+5) & 0x1f; // Number of sps

  8297.         p += 6;

  8298.         for (i = 0; i < cnt; i++) {

  8299.             nalsize = BE_16(p) + 2;

  8300.             if(decode_nal_units(h, p, nalsize) < 0) {

  8301.                 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i);

  8302.                 return -1;

  8303.             }

  8304.             p += nalsize;

  8305.         }

  8306.         // Decode pps from avcC

  8307.         cnt = *(p++); // Number of pps

  8308.         for (i = 0; i < cnt; i++) {

  8309.             nalsize = BE_16(p) + 2;

  8310.             if(decode_nal_units(h, p, nalsize)  != nalsize) {

  8311.                 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i);

  8312.                 return -1;

  8313.             }

  8314.             p += nalsize;

  8315.         }

  8316.         // Now store right nal length size, that will be use to parse all other nals

  8317.         h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1;

  8318.         // Do not reparse avcC

  8319.         h->got_avcC = 1;

  8320.     }

  8321. 

  8322.     if(!h->is_avc && s->avctx->extradata_size && s->picture_number==0){

  8323.         if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0)

  8324.             return -1;

  8325.     }

  8326. 

  8327.     buf_index=decode_nal_units(h, buf, buf_size);

  8328.     if(buf_index < 0)

  8329.         return -1;

  8330. 

  8331.     //FIXME do something with unavailable reference frames

  8332. 

  8333. //    if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_index, buf_size);

  8334.     if(!s->current_picture_ptr){

  8335.         av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n");

  8336.         return -1;

  8337.     }

  8338. 

  8339.     {

  8340.         Picture *out = s->current_picture_ptr;

  8341. #if 0 //decode order

  8342.         *data_size = sizeof(AVFrame);

  8343. #else

  8344.         /* Sort B-frames into display order */

  8345.         Picture *cur = s->current_picture_ptr;

  8346.         Picture *prev = h->delayed_output_pic;

  8347.         int i, pics, cross_idr, out_of_order, out_idx;

  8348. 

  8349.         if(h->sps.bitstream_restriction_flag

  8350.            && s->avctx->has_b_frames < h->sps.num_reorder_frames){

  8351.             s->avctx->has_b_frames = h->sps.num_reorder_frames;

  8352.             s->low_delay = 0;

  8353.         }

  8354. 

  8355.         pics = 0;

  8356.         while(h->delayed_pic[pics]) pics++;

  8357.         h->delayed_pic[pics++] = cur;

  8358.         if(cur->reference == 0)

  8359.             cur->reference = 1;

  8360. 

  8361.         cross_idr = 0;

  8362.         for(i=0; h->delayed_pic[i]; i++)

  8363.             if(h->delayed_pic[i]->key_frame || h->delayed_pic[i]->poc==0)

  8364.                 cross_idr = 1;

  8365. 

  8366.         out = h->delayed_pic[0];

  8367.         out_idx = 0;

  8368.         for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame; i++)

  8369.             if(h->delayed_pic[i]->poc < out->poc){

  8370.                 out = h->delayed_pic[i];

  8371.                 out_idx = i;

  8372.             }

  8373. 

  8374.         out_of_order = !cross_idr && prev && out->poc < prev->poc;

  8375.         if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames)

  8376.             { }

  8377.         else if(prev && pics <= s->avctx->has_b_frames)

  8378.             out = prev;

  8379.         else if((out_of_order && pics-1 == s->avctx->has_b_frames && pics < 15)

  8380.            || (s->low_delay &&

  8381.             ((!cross_idr && prev && out->poc > prev->poc + 2)

  8382.              || cur->pict_type == B_TYPE)))

  8383.         {

  8384.             s->low_delay = 0;

  8385.             s->avctx->has_b_frames++;

  8386.             out = prev;

  8387.         }

  8388.         else if(out_of_order)

  8389.             out = prev;

  8390. 

  8391.         if(out_of_order || pics > s->avctx->has_b_frames){

  8392.             for(i=out_idx; h->delayed_pic[i]; i++)

  8393.                 h->delayed_pic[i] = h->delayed_pic[i+1];

  8394.         }

  8395. 

  8396.         if(prev == out)

  8397.             *data_size = 0;

  8398.         else

  8399.             *data_size = sizeof(AVFrame);

  8400.         if(prev && prev != out && prev->reference == 1)

  8401.             prev->reference = 0;

  8402.         h->delayed_output_pic = out;

  8403. #endif

  8404. 

  8405.         if(out)

  8406.             *pict= *(AVFrame*)out;

  8407.         else

  8408.             av_log(avctx, AV_LOG_DEBUG, "no picture\n");

  8409.     }

  8410. 

  8411.     assert(pict->data[0] || !*data_size);

  8412.     ff_print_debug_info(s, pict);

  8413. //printf("out %d\n", (int)pict->data[0]);

  8414. #if 0 //?

  8415. 

  8416.     /* Return the Picture timestamp as the frame number */

  8417.     /* we substract 1 because it is added on utils.c    */

  8418.     avctx->frame_number = s->picture_number - 1;

  8419. #endif

  8420.     return get_consumed_bytes(s, buf_index, buf_size);

  8421. }

  8422. #if 0

  8423. static inline void fill_mb_avail(H264Context *h){

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

  8425.     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;

  8426. 

  8427.     if(s->mb_y){

  8428.         h->mb_avail[0]= s->mb_x                 && h->slice_table[mb_xy - s->mb_stride - 1] == h->slice_num;

  8429.         h->mb_avail[1]=                            h->slice_table[mb_xy - s->mb_stride    ] == h->slice_num;

  8430.         h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num;

  8431.     }else{

  8432.         h->mb_avail[0]=

  8433.         h->mb_avail[1]=

  8434.         h->mb_avail[2]= 0;

  8435.     }

  8436.     h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num;

  8437.     h->mb_avail[4]= 1; //FIXME move out

  8438.     h->mb_avail[5]= 0; //FIXME move out

  8439. }

  8440. #endif

  8441. 

  8442. #if 0 //selftest

  8443. #define COUNT 8000

  8444. #define SIZE (COUNT*40)

  8445. int main(){

  8446.     int i;

  8447.     uint8_t temp[SIZE];

  8448.     PutBitContext pb;

  8449.     GetBitContext gb;

  8450. //    int int_temp[10000];

  8451.     DSPContext dsp;

  8452.     AVCodecContext avctx;

  8453. 

  8454.     dsputil_init(&dsp, &avctx);

  8455. 

  8456.     init_put_bits(&pb, temp, SIZE);

  8457.     printf("testing unsigned exp golomb\n");

  8458.     for(i=0; i<COUNT; i++){

  8459.         START_TIMER

  8460.         set_ue_golomb(&pb, i);

  8461.         STOP_TIMER("set_ue_golomb");

  8462.     }

  8463.     flush_put_bits(&pb);

  8464. 

  8465.     init_get_bits(&gb, temp, 8*SIZE);

  8466.     for(i=0; i<COUNT; i++){

  8467.         int j, s;

  8468. 

  8469.         s= show_bits(&gb, 24);

  8470. 

  8471.         START_TIMER

  8472.         j= get_ue_golomb(&gb);

  8473.         if(j != i){

  8474.             printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);

  8475. //            return -1;

  8476.         }

  8477.         STOP_TIMER("get_ue_golomb");

  8478.     }

  8479. 

  8480. 

  8481.     init_put_bits(&pb, temp, SIZE);

  8482.     printf("testing signed exp golomb\n");

  8483.     for(i=0; i<COUNT; i++){

  8484.         START_TIMER

  8485.         set_se_golomb(&pb, i - COUNT/2);

  8486.         STOP_TIMER("set_se_golomb");

  8487.     }

  8488.     flush_put_bits(&pb);

  8489. 

  8490.     init_get_bits(&gb, temp, 8*SIZE);

  8491.     for(i=0; i<COUNT; i++){

  8492.         int j, s;

  8493. 

  8494.         s= show_bits(&gb, 24);

  8495. 

  8496.         START_TIMER

  8497.         j= get_se_golomb(&gb);

  8498.         if(j != i - COUNT/2){

  8499.             printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);

  8500. //            return -1;

  8501.         }

  8502.         STOP_TIMER("get_se_golomb");

  8503.     }

  8504. 

  8505.     printf("testing 4x4 (I)DCT\n");

  8506. 

  8507.     DCTELEM block[16];

  8508.     uint8_t src[16], ref[16];

  8509.     uint64_t error= 0, max_error=0;

  8510. 

  8511.     for(i=0; i<COUNT; i++){

  8512.         int j;

  8513. //        printf("%d %d %d\n", r1, r2, (r2-r1)*16);

  8514.         for(j=0; j<16; j++){

  8515.             ref[j]= random()%255;

  8516.             src[j]= random()%255;

  8517.         }

  8518. 

  8519.         h264_diff_dct_c(block, src, ref, 4);

  8520. 

  8521.         //normalize

  8522.         for(j=0; j<16; j++){

  8523. //            printf("%d ", block[j]);

  8524.             block[j]= block[j]*4;

  8525.             if(j&1) block[j]= (block[j]*4 + 2)/5;

  8526.             if(j&4) block[j]= (block[j]*4 + 2)/5;

  8527.         }

  8528. //        printf("\n");

  8529. 

  8530.         s->dsp.h264_idct_add(ref, block, 4);

  8531. /*        for(j=0; j<16; j++){

  8532.             printf("%d ", ref[j]);

  8533.         }

  8534.         printf("\n");*/

  8535. 

  8536.         for(j=0; j<16; j++){

  8537.             int diff= FFABS(src[j] - ref[j]);

  8538. 

  8539.             error+= diff*diff;

  8540.             max_error= FFMAX(max_error, diff);

  8541.         }

  8542.     }

  8543.     printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error );

  8544. #if 0

  8545.     printf("testing quantizer\n");

  8546.     for(qp=0; qp<52; qp++){

  8547.         for(i=0; i<16; i++)

  8548.             src1_block[i]= src2_block[i]= random()%255;

  8549. 

  8550.     }

  8551. #endif

  8552.     printf("Testing NAL layer\n");

  8553. 

  8554.     uint8_t bitstream[COUNT];

  8555.     uint8_t nal[COUNT*2];

  8556.     H264Context h;

  8557.     memset(&h, 0, sizeof(H264Context));

  8558. 

  8559.     for(i=0; i<COUNT; i++){

  8560.         int zeros= i;

  8561.         int nal_length;

  8562.         int consumed;

  8563.         int out_length;

  8564.         uint8_t *out;

  8565.         int j;

  8566. 

  8567.         for(j=0; j<COUNT; j++){

  8568.             bitstream[j]= (random() % 255) + 1;

  8569.         }

  8570. 

  8571.         for(j=0; j<zeros; j++){

  8572.             int pos= random() % COUNT;

  8573.             while(bitstream[pos] == 0){

  8574.                 pos++;

  8575.                 pos %= COUNT;

  8576.             }

  8577.             bitstream[pos]=0;

  8578.         }

  8579. 

  8580.         START_TIMER

  8581. 

  8582.         nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2);

  8583.         if(nal_length<0){

  8584.             printf("encoding failed\n");

  8585.             return -1;

  8586.         }

  8587. 

  8588.         out= decode_nal(&h, nal, &out_length, &consumed, nal_length);

  8589. 

  8590.         STOP_TIMER("NAL")

  8591. 

  8592.         if(out_length != COUNT){

  8593.             printf("incorrect length %d %d\n", out_length, COUNT);

  8594.             return -1;

  8595.         }

  8596. 

  8597.         if(consumed != nal_length){

  8598.             printf("incorrect consumed length %d %d\n", nal_length, consumed);

  8599.             return -1;

  8600.         }

  8601. 

  8602.         if(memcmp(bitstream, out, COUNT)){

  8603.             printf("missmatch\n");

  8604.             return -1;

  8605.         }

  8606.     }

  8607. 

  8608.     printf("Testing RBSP\n");

  8609. 

  8610. 

  8611.     return 0;

  8612. }

  8613. #endif

  8614. 

  8615. 

  8616. static int decode_end(AVCodecContext *avctx)

  8617. {

  8618.     H264Context *h = avctx->priv_data;

  8619.     MpegEncContext *s = &h->s;

  8620. 

  8621.     av_freep(&h->rbsp_buffer);

  8622.     free_tables(h); //FIXME cleanup init stuff perhaps

  8623.     MPV_common_end(s);

  8624. 

  8625. //    memset(h, 0, sizeof(H264Context));

  8626. 

  8627.     return 0;

  8628. }

  8629. 

  8630. 

  8631. AVCodec h264_decoder = {

  8632.     "h264",

  8633.     CODEC_TYPE_VIDEO,

  8634.     CODEC_ID_H264,

  8635.     sizeof(H264Context),

  8636.     decode_init,

  8637.     NULL,

  8638.     decode_end,

  8639.     decode_frame,

  8640.     /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,

  8641.     .flush= flush_dpb,

  8642. };

  8643. 

  8644. #ifdef CONFIG_H264_PARSER

  8645. AVCodecParser h264_parser = {

  8646.     { CODEC_ID_H264 },

  8647.     sizeof(H264Context),

  8648.     NULL,

  8649.     h264_parse,

  8650.     ff_parse_close,

  8651.     h264_split,

  8652. };

  8653. #endif

  8654. 

  8655. #include "svq3.c"