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.

8508 lines
317KB

  1. /*
  2. * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
  3. * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
  4. *
  5. * This library is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU Lesser General Public
  7. * License as published by the Free Software Foundation; either
  8. * version 2 of the License, or (at your option) any later version.
  9. *
  10. * This library is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13. * Lesser General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU Lesser General Public
  16. * License along with this library; if not, write to the Free Software
  17. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  18. *
  19. */
  20. /**
  21. * @file h264.c
  22. * H.264 / AVC / MPEG4 part10 codec.
  23. * @author Michael Niedermayer <michaelni@gmx.at>
  24. */
  25. #include "common.h"
  26. #include "dsputil.h"
  27. #include "avcodec.h"
  28. #include "mpegvideo.h"
  29. #include "h264data.h"
  30. #include "golomb.h"
  31. #include "cabac.h"
  32. //#undef NDEBUG
  33. #include <assert.h>
  34. #define interlaced_dct interlaced_dct_is_a_bad_name
  35. #define mb_intra mb_intra_isnt_initalized_see_mb_type
  36. #define LUMA_DC_BLOCK_INDEX 25
  37. #define CHROMA_DC_BLOCK_INDEX 26
  38. #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8
  39. #define COEFF_TOKEN_VLC_BITS 8
  40. #define TOTAL_ZEROS_VLC_BITS 9
  41. #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3
  42. #define RUN_VLC_BITS 3
  43. #define RUN7_VLC_BITS 6
  44. #define MAX_SPS_COUNT 32
  45. #define MAX_PPS_COUNT 256
  46. #define MAX_MMCO_COUNT 66
  47. /* Compiling in interlaced support reduces the speed
  48. * of progressive decoding by about 2%. */
  49. #define ALLOW_INTERLACE
  50. #ifdef ALLOW_INTERLACE
  51. #define MB_MBAFF h->mb_mbaff
  52. #define MB_FIELD h->mb_field_decoding_flag
  53. #define FRAME_MBAFF h->mb_aff_frame
  54. #else
  55. #define MB_MBAFF 0
  56. #define MB_FIELD 0
  57. #define FRAME_MBAFF 0
  58. #undef IS_INTERLACED
  59. #define IS_INTERLACED(mb_type) 0
  60. #endif
  61. /**
  62. * Sequence parameter set
  63. */
  64. typedef struct SPS{
  65. int profile_idc;
  66. int level_idc;
  67. int transform_bypass; ///< qpprime_y_zero_transform_bypass_flag
  68. int log2_max_frame_num; ///< log2_max_frame_num_minus4 + 4
  69. int poc_type; ///< pic_order_cnt_type
  70. int log2_max_poc_lsb; ///< log2_max_pic_order_cnt_lsb_minus4
  71. int delta_pic_order_always_zero_flag;
  72. int offset_for_non_ref_pic;
  73. int offset_for_top_to_bottom_field;
  74. int poc_cycle_length; ///< num_ref_frames_in_pic_order_cnt_cycle
  75. int ref_frame_count; ///< num_ref_frames
  76. int gaps_in_frame_num_allowed_flag;
  77. int mb_width; ///< frame_width_in_mbs_minus1 + 1
  78. int mb_height; ///< frame_height_in_mbs_minus1 + 1
  79. int frame_mbs_only_flag;
  80. int mb_aff; ///<mb_adaptive_frame_field_flag
  81. int direct_8x8_inference_flag;
  82. int crop; ///< frame_cropping_flag
  83. int crop_left; ///< frame_cropping_rect_left_offset
  84. int crop_right; ///< frame_cropping_rect_right_offset
  85. int crop_top; ///< frame_cropping_rect_top_offset
  86. int crop_bottom; ///< frame_cropping_rect_bottom_offset
  87. int vui_parameters_present_flag;
  88. AVRational sar;
  89. int timing_info_present_flag;
  90. uint32_t num_units_in_tick;
  91. uint32_t time_scale;
  92. int fixed_frame_rate_flag;
  93. short offset_for_ref_frame[256]; //FIXME dyn aloc?
  94. int bitstream_restriction_flag;
  95. int num_reorder_frames;
  96. int scaling_matrix_present;
  97. uint8_t scaling_matrix4[6][16];
  98. uint8_t scaling_matrix8[2][64];
  99. }SPS;
  100. /**
  101. * Picture parameter set
  102. */
  103. typedef struct PPS{
  104. int sps_id;
  105. int cabac; ///< entropy_coding_mode_flag
  106. int pic_order_present; ///< pic_order_present_flag
  107. int slice_group_count; ///< num_slice_groups_minus1 + 1
  108. int mb_slice_group_map_type;
  109. int ref_count[2]; ///< num_ref_idx_l0/1_active_minus1 + 1
  110. int weighted_pred; ///< weighted_pred_flag
  111. int weighted_bipred_idc;
  112. int init_qp; ///< pic_init_qp_minus26 + 26
  113. int init_qs; ///< pic_init_qs_minus26 + 26
  114. int chroma_qp_index_offset;
  115. int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag
  116. int constrained_intra_pred; ///< constrained_intra_pred_flag
  117. int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag
  118. int transform_8x8_mode; ///< transform_8x8_mode_flag
  119. uint8_t scaling_matrix4[6][16];
  120. uint8_t scaling_matrix8[2][64];
  121. }PPS;
  122. /**
  123. * Memory management control operation opcode.
  124. */
  125. typedef enum MMCOOpcode{
  126. MMCO_END=0,
  127. MMCO_SHORT2UNUSED,
  128. MMCO_LONG2UNUSED,
  129. MMCO_SHORT2LONG,
  130. MMCO_SET_MAX_LONG,
  131. MMCO_RESET,
  132. MMCO_LONG,
  133. } MMCOOpcode;
  134. /**
  135. * Memory management control operation.
  136. */
  137. typedef struct MMCO{
  138. MMCOOpcode opcode;
  139. int short_frame_num;
  140. int long_index;
  141. } MMCO;
  142. /**
  143. * H264Context
  144. */
  145. typedef struct H264Context{
  146. MpegEncContext s;
  147. int nal_ref_idc;
  148. int nal_unit_type;
  149. #define NAL_SLICE 1
  150. #define NAL_DPA 2
  151. #define NAL_DPB 3
  152. #define NAL_DPC 4
  153. #define NAL_IDR_SLICE 5
  154. #define NAL_SEI 6
  155. #define NAL_SPS 7
  156. #define NAL_PPS 8
  157. #define NAL_AUD 9
  158. #define NAL_END_SEQUENCE 10
  159. #define NAL_END_STREAM 11
  160. #define NAL_FILLER_DATA 12
  161. #define NAL_SPS_EXT 13
  162. #define NAL_AUXILIARY_SLICE 19
  163. uint8_t *rbsp_buffer;
  164. unsigned int rbsp_buffer_size;
  165. /**
  166. * Used to parse AVC variant of h264
  167. */
  168. int is_avc; ///< this flag is != 0 if codec is avc1
  169. int got_avcC; ///< flag used to parse avcC data only once
  170. int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4)
  171. int chroma_qp; //QPc
  172. int prev_mb_skipped;
  173. int next_mb_skipped;
  174. //prediction stuff
  175. int chroma_pred_mode;
  176. int intra16x16_pred_mode;
  177. int top_mb_xy;
  178. int left_mb_xy[2];
  179. int8_t intra4x4_pred_mode_cache[5*8];
  180. int8_t (*intra4x4_pred_mode)[8];
  181. void (*pred4x4 [9+3])(uint8_t *src, uint8_t *topright, int stride);//FIXME move to dsp?
  182. void (*pred8x8l [9+3])(uint8_t *src, int topleft, int topright, int stride);
  183. void (*pred8x8 [4+3])(uint8_t *src, int stride);
  184. void (*pred16x16[4+3])(uint8_t *src, int stride);
  185. unsigned int topleft_samples_available;
  186. unsigned int top_samples_available;
  187. unsigned int topright_samples_available;
  188. unsigned int left_samples_available;
  189. uint8_t (*top_borders[2])[16+2*8];
  190. uint8_t left_border[2*(17+2*9)];
  191. /**
  192. * non zero coeff count cache.
  193. * is 64 if not available.
  194. */
  195. DECLARE_ALIGNED_8(uint8_t, non_zero_count_cache[6*8]);
  196. uint8_t (*non_zero_count)[16];
  197. /**
  198. * Motion vector cache.
  199. */
  200. DECLARE_ALIGNED_8(int16_t, mv_cache[2][5*8][2]);
  201. DECLARE_ALIGNED_8(int8_t, ref_cache[2][5*8]);
  202. #define LIST_NOT_USED -1 //FIXME rename?
  203. #define PART_NOT_AVAILABLE -2
  204. /**
  205. * is 1 if the specific list MV&references are set to 0,0,-2.
  206. */
  207. int mv_cache_clean[2];
  208. /**
  209. * number of neighbors (top and/or left) that used 8x8 dct
  210. */
  211. int neighbor_transform_size;
  212. /**
  213. * block_offset[ 0..23] for frame macroblocks
  214. * block_offset[24..47] for field macroblocks
  215. */
  216. int block_offset[2*(16+8)];
  217. uint32_t *mb2b_xy; //FIXME are these 4 a good idea?
  218. uint32_t *mb2b8_xy;
  219. int b_stride; //FIXME use s->b4_stride
  220. int b8_stride;
  221. int mb_linesize; ///< may be equal to s->linesize or s->linesize*2, for mbaff
  222. int mb_uvlinesize;
  223. int emu_edge_width;
  224. int emu_edge_height;
  225. int halfpel_flag;
  226. int thirdpel_flag;
  227. int unknown_svq3_flag;
  228. int next_slice_index;
  229. SPS sps_buffer[MAX_SPS_COUNT];
  230. SPS sps; ///< current sps
  231. PPS pps_buffer[MAX_PPS_COUNT];
  232. /**
  233. * current pps
  234. */
  235. PPS pps; //FIXME move to Picture perhaps? (->no) do we need that?
  236. uint32_t dequant4_buffer[6][52][16];
  237. uint32_t dequant8_buffer[2][52][64];
  238. uint32_t (*dequant4_coeff[6])[16];
  239. uint32_t (*dequant8_coeff[2])[64];
  240. int dequant_coeff_pps; ///< reinit tables when pps changes
  241. int slice_num;
  242. uint8_t *slice_table_base;
  243. uint8_t *slice_table; ///< slice_table_base + 2*mb_stride + 1
  244. int slice_type;
  245. int slice_type_fixed;
  246. //interlacing specific flags
  247. int mb_aff_frame;
  248. int mb_field_decoding_flag;
  249. int mb_mbaff; ///< mb_aff_frame && mb_field_decoding_flag
  250. int sub_mb_type[4];
  251. //POC stuff
  252. int poc_lsb;
  253. int poc_msb;
  254. int delta_poc_bottom;
  255. int delta_poc[2];
  256. int frame_num;
  257. int prev_poc_msb; ///< poc_msb of the last reference pic for POC type 0
  258. int prev_poc_lsb; ///< poc_lsb of the last reference pic for POC type 0
  259. int frame_num_offset; ///< for POC type 2
  260. int prev_frame_num_offset; ///< for POC type 2
  261. int prev_frame_num; ///< frame_num of the last pic for POC type 1/2
  262. /**
  263. * frame_num for frames or 2*frame_num for field pics.
  264. */
  265. int curr_pic_num;
  266. /**
  267. * max_frame_num or 2*max_frame_num for field pics.
  268. */
  269. int max_pic_num;
  270. //Weighted pred stuff
  271. int use_weight;
  272. int use_weight_chroma;
  273. int luma_log2_weight_denom;
  274. int chroma_log2_weight_denom;
  275. int luma_weight[2][48];
  276. int luma_offset[2][48];
  277. int chroma_weight[2][48][2];
  278. int chroma_offset[2][48][2];
  279. int implicit_weight[48][48];
  280. //deblock
  281. int deblocking_filter; ///< disable_deblocking_filter_idc with 1<->0
  282. int slice_alpha_c0_offset;
  283. int slice_beta_offset;
  284. int redundant_pic_count;
  285. int direct_spatial_mv_pred;
  286. int dist_scale_factor[16];
  287. int dist_scale_factor_field[32];
  288. int map_col_to_list0[2][16];
  289. int map_col_to_list0_field[2][32];
  290. /**
  291. * num_ref_idx_l0/1_active_minus1 + 1
  292. */
  293. int ref_count[2]; ///< counts frames or fields, depending on current mb mode
  294. Picture *short_ref[32];
  295. Picture *long_ref[32];
  296. Picture default_ref_list[2][32];
  297. Picture ref_list[2][48]; ///< 0..15: frame refs, 16..47: mbaff field refs
  298. Picture *delayed_pic[16]; //FIXME size?
  299. Picture *delayed_output_pic;
  300. /**
  301. * memory management control operations buffer.
  302. */
  303. MMCO mmco[MAX_MMCO_COUNT];
  304. int mmco_index;
  305. int long_ref_count; ///< number of actual long term references
  306. int short_ref_count; ///< number of actual short term references
  307. //data partitioning
  308. GetBitContext intra_gb;
  309. GetBitContext inter_gb;
  310. GetBitContext *intra_gb_ptr;
  311. GetBitContext *inter_gb_ptr;
  312. DECLARE_ALIGNED_8(DCTELEM, mb[16*24]);
  313. /**
  314. * Cabac
  315. */
  316. CABACContext cabac;
  317. uint8_t cabac_state[460];
  318. int cabac_init_idc;
  319. /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */
  320. uint16_t *cbp_table;
  321. int top_cbp;
  322. int left_cbp;
  323. /* chroma_pred_mode for i4x4 or i16x16, else 0 */
  324. uint8_t *chroma_pred_mode_table;
  325. int last_qscale_diff;
  326. int16_t (*mvd_table[2])[2];
  327. DECLARE_ALIGNED_8(int16_t, mvd_cache[2][5*8][2]);
  328. uint8_t *direct_table;
  329. uint8_t direct_cache[5*8];
  330. uint8_t zigzag_scan[16];
  331. uint8_t zigzag_scan8x8[64];
  332. uint8_t zigzag_scan8x8_cavlc[64];
  333. uint8_t field_scan[16];
  334. uint8_t field_scan8x8[64];
  335. uint8_t field_scan8x8_cavlc[64];
  336. const uint8_t *zigzag_scan_q0;
  337. const uint8_t *zigzag_scan8x8_q0;
  338. const uint8_t *zigzag_scan8x8_cavlc_q0;
  339. const uint8_t *field_scan_q0;
  340. const uint8_t *field_scan8x8_q0;
  341. const uint8_t *field_scan8x8_cavlc_q0;
  342. int x264_build;
  343. }H264Context;
  344. static VLC coeff_token_vlc[4];
  345. static VLC chroma_dc_coeff_token_vlc;
  346. static VLC total_zeros_vlc[15];
  347. static VLC chroma_dc_total_zeros_vlc[3];
  348. static VLC run_vlc[6];
  349. static VLC run7_vlc;
  350. static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp);
  351. static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc);
  352. 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);
  353. static always_inline uint32_t pack16to32(int a, int b){
  354. #ifdef WORDS_BIGENDIAN
  355. return (b&0xFFFF) + (a<<16);
  356. #else
  357. return (a&0xFFFF) + (b<<16);
  358. #endif
  359. }
  360. /**
  361. * fill a rectangle.
  362. * @param h height of the rectangle, should be a constant
  363. * @param w width of the rectangle, should be a constant
  364. * @param size the size of val (1 or 4), should be a constant
  365. */
  366. static always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){
  367. uint8_t *p= (uint8_t*)vp;
  368. assert(size==1 || size==4);
  369. assert(w<=4);
  370. w *= size;
  371. stride *= size;
  372. assert((((long)vp)&(FFMIN(w, STRIDE_ALIGN)-1)) == 0);
  373. assert((stride&(w-1))==0);
  374. if(w==2){
  375. const uint16_t v= size==4 ? val : val*0x0101;
  376. *(uint16_t*)(p + 0*stride)= v;
  377. if(h==1) return;
  378. *(uint16_t*)(p + 1*stride)= v;
  379. if(h==2) return;
  380. *(uint16_t*)(p + 2*stride)=
  381. *(uint16_t*)(p + 3*stride)= v;
  382. }else if(w==4){
  383. const uint32_t v= size==4 ? val : val*0x01010101;
  384. *(uint32_t*)(p + 0*stride)= v;
  385. if(h==1) return;
  386. *(uint32_t*)(p + 1*stride)= v;
  387. if(h==2) return;
  388. *(uint32_t*)(p + 2*stride)=
  389. *(uint32_t*)(p + 3*stride)= v;
  390. }else if(w==8){
  391. //gcc can't optimize 64bit math on x86_32
  392. #if defined(ARCH_X86_64) || (defined(MP_WORDSIZE) && MP_WORDSIZE >= 64)
  393. const uint64_t v= val*0x0100000001ULL;
  394. *(uint64_t*)(p + 0*stride)= v;
  395. if(h==1) return;
  396. *(uint64_t*)(p + 1*stride)= v;
  397. if(h==2) return;
  398. *(uint64_t*)(p + 2*stride)=
  399. *(uint64_t*)(p + 3*stride)= v;
  400. }else if(w==16){
  401. const uint64_t v= val*0x0100000001ULL;
  402. *(uint64_t*)(p + 0+0*stride)=
  403. *(uint64_t*)(p + 8+0*stride)=
  404. *(uint64_t*)(p + 0+1*stride)=
  405. *(uint64_t*)(p + 8+1*stride)= v;
  406. if(h==2) return;
  407. *(uint64_t*)(p + 0+2*stride)=
  408. *(uint64_t*)(p + 8+2*stride)=
  409. *(uint64_t*)(p + 0+3*stride)=
  410. *(uint64_t*)(p + 8+3*stride)= v;
  411. #else
  412. *(uint32_t*)(p + 0+0*stride)=
  413. *(uint32_t*)(p + 4+0*stride)= val;
  414. if(h==1) return;
  415. *(uint32_t*)(p + 0+1*stride)=
  416. *(uint32_t*)(p + 4+1*stride)= val;
  417. if(h==2) return;
  418. *(uint32_t*)(p + 0+2*stride)=
  419. *(uint32_t*)(p + 4+2*stride)=
  420. *(uint32_t*)(p + 0+3*stride)=
  421. *(uint32_t*)(p + 4+3*stride)= val;
  422. }else if(w==16){
  423. *(uint32_t*)(p + 0+0*stride)=
  424. *(uint32_t*)(p + 4+0*stride)=
  425. *(uint32_t*)(p + 8+0*stride)=
  426. *(uint32_t*)(p +12+0*stride)=
  427. *(uint32_t*)(p + 0+1*stride)=
  428. *(uint32_t*)(p + 4+1*stride)=
  429. *(uint32_t*)(p + 8+1*stride)=
  430. *(uint32_t*)(p +12+1*stride)= val;
  431. if(h==2) return;
  432. *(uint32_t*)(p + 0+2*stride)=
  433. *(uint32_t*)(p + 4+2*stride)=
  434. *(uint32_t*)(p + 8+2*stride)=
  435. *(uint32_t*)(p +12+2*stride)=
  436. *(uint32_t*)(p + 0+3*stride)=
  437. *(uint32_t*)(p + 4+3*stride)=
  438. *(uint32_t*)(p + 8+3*stride)=
  439. *(uint32_t*)(p +12+3*stride)= val;
  440. #endif
  441. }else
  442. assert(0);
  443. assert(h==4);
  444. }
  445. static void fill_caches(H264Context *h, int mb_type, int for_deblock){
  446. MpegEncContext * const s = &h->s;
  447. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  448. int topleft_xy, top_xy, topright_xy, left_xy[2];
  449. int topleft_type, top_type, topright_type, left_type[2];
  450. int left_block[8];
  451. int i;
  452. //FIXME deblocking can skip fill_caches much of the time with multiple slices too.
  453. // the actual condition is whether we're on the edge of a slice,
  454. // and even then the intra and nnz parts are unnecessary.
  455. if(for_deblock && h->slice_num == 1 && !FRAME_MBAFF)
  456. return;
  457. //wow what a mess, why didn't they simplify the interlacing&intra stuff, i can't imagine that these complex rules are worth it
  458. top_xy = mb_xy - s->mb_stride;
  459. topleft_xy = top_xy - 1;
  460. topright_xy= top_xy + 1;
  461. left_xy[1] = left_xy[0] = mb_xy-1;
  462. left_block[0]= 0;
  463. left_block[1]= 1;
  464. left_block[2]= 2;
  465. left_block[3]= 3;
  466. left_block[4]= 7;
  467. left_block[5]= 10;
  468. left_block[6]= 8;
  469. left_block[7]= 11;
  470. if(FRAME_MBAFF){
  471. const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride;
  472. const int top_pair_xy = pair_xy - s->mb_stride;
  473. const int topleft_pair_xy = top_pair_xy - 1;
  474. const int topright_pair_xy = top_pair_xy + 1;
  475. const int topleft_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]);
  476. const int top_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
  477. const int topright_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]);
  478. const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
  479. const int curr_mb_frame_flag = !IS_INTERLACED(mb_type);
  480. const int bottom = (s->mb_y & 1);
  481. 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);
  482. if (bottom
  483. ? !curr_mb_frame_flag // bottom macroblock
  484. : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock
  485. ) {
  486. top_xy -= s->mb_stride;
  487. }
  488. if (bottom
  489. ? !curr_mb_frame_flag // bottom macroblock
  490. : (!curr_mb_frame_flag && !topleft_mb_frame_flag) // top macroblock
  491. ) {
  492. topleft_xy -= s->mb_stride;
  493. }
  494. if (bottom
  495. ? !curr_mb_frame_flag // bottom macroblock
  496. : (!curr_mb_frame_flag && !topright_mb_frame_flag) // top macroblock
  497. ) {
  498. topright_xy -= s->mb_stride;
  499. }
  500. if (left_mb_frame_flag != curr_mb_frame_flag) {
  501. left_xy[1] = left_xy[0] = pair_xy - 1;
  502. if (curr_mb_frame_flag) {
  503. if (bottom) {
  504. left_block[0]= 2;
  505. left_block[1]= 2;
  506. left_block[2]= 3;
  507. left_block[3]= 3;
  508. left_block[4]= 8;
  509. left_block[5]= 11;
  510. left_block[6]= 8;
  511. left_block[7]= 11;
  512. } else {
  513. left_block[0]= 0;
  514. left_block[1]= 0;
  515. left_block[2]= 1;
  516. left_block[3]= 1;
  517. left_block[4]= 7;
  518. left_block[5]= 10;
  519. left_block[6]= 7;
  520. left_block[7]= 10;
  521. }
  522. } else {
  523. left_xy[1] += s->mb_stride;
  524. //left_block[0]= 0;
  525. left_block[1]= 2;
  526. left_block[2]= 0;
  527. left_block[3]= 2;
  528. //left_block[4]= 7;
  529. left_block[5]= 10;
  530. left_block[6]= 7;
  531. left_block[7]= 10;
  532. }
  533. }
  534. }
  535. h->top_mb_xy = top_xy;
  536. h->left_mb_xy[0] = left_xy[0];
  537. h->left_mb_xy[1] = left_xy[1];
  538. if(for_deblock){
  539. topleft_type = h->slice_table[topleft_xy ] < 255 ? s->current_picture.mb_type[topleft_xy] : 0;
  540. top_type = h->slice_table[top_xy ] < 255 ? s->current_picture.mb_type[top_xy] : 0;
  541. topright_type= h->slice_table[topright_xy] < 255 ? s->current_picture.mb_type[topright_xy]: 0;
  542. left_type[0] = h->slice_table[left_xy[0] ] < 255 ? s->current_picture.mb_type[left_xy[0]] : 0;
  543. left_type[1] = h->slice_table[left_xy[1] ] < 255 ? s->current_picture.mb_type[left_xy[1]] : 0;
  544. if(FRAME_MBAFF && !IS_INTRA(mb_type)){
  545. int list;
  546. int v = *(uint16_t*)&h->non_zero_count[mb_xy][14];
  547. for(i=0; i<16; i++)
  548. h->non_zero_count_cache[scan8[i]] = (v>>i)&1;
  549. for(list=0; list<1+(h->slice_type==B_TYPE); list++){
  550. if(USES_LIST(mb_type,list)){
  551. uint32_t *src = (uint32_t*)s->current_picture.motion_val[list][h->mb2b_xy[mb_xy]];
  552. uint32_t *dst = (uint32_t*)h->mv_cache[list][scan8[0]];
  553. uint8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]];
  554. for(i=0; i<4; i++, dst+=8, src+=h->b_stride){
  555. dst[0] = src[0];
  556. dst[1] = src[1];
  557. dst[2] = src[2];
  558. dst[3] = src[3];
  559. }
  560. *(uint32_t*)&h->ref_cache[list][scan8[ 0]] =
  561. *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = pack16to32(ref[0],ref[1])*0x0101;
  562. ref += h->b8_stride;
  563. *(uint32_t*)&h->ref_cache[list][scan8[ 8]] =
  564. *(uint32_t*)&h->ref_cache[list][scan8[10]] = pack16to32(ref[0],ref[1])*0x0101;
  565. }else{
  566. fill_rectangle(&h-> mv_cache[list][scan8[ 0]], 4, 4, 8, 0, 4);
  567. fill_rectangle(&h->ref_cache[list][scan8[ 0]], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1);
  568. }
  569. }
  570. }
  571. }else{
  572. topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0;
  573. top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0;
  574. topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0;
  575. left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0;
  576. left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0;
  577. }
  578. if(IS_INTRA(mb_type)){
  579. h->topleft_samples_available=
  580. h->top_samples_available=
  581. h->left_samples_available= 0xFFFF;
  582. h->topright_samples_available= 0xEEEA;
  583. if(!IS_INTRA(top_type) && (top_type==0 || h->pps.constrained_intra_pred)){
  584. h->topleft_samples_available= 0xB3FF;
  585. h->top_samples_available= 0x33FF;
  586. h->topright_samples_available= 0x26EA;
  587. }
  588. for(i=0; i<2; i++){
  589. if(!IS_INTRA(left_type[i]) && (left_type[i]==0 || h->pps.constrained_intra_pred)){
  590. h->topleft_samples_available&= 0xDF5F;
  591. h->left_samples_available&= 0x5F5F;
  592. }
  593. }
  594. if(!IS_INTRA(topleft_type) && (topleft_type==0 || h->pps.constrained_intra_pred))
  595. h->topleft_samples_available&= 0x7FFF;
  596. if(!IS_INTRA(topright_type) && (topright_type==0 || h->pps.constrained_intra_pred))
  597. h->topright_samples_available&= 0xFBFF;
  598. if(IS_INTRA4x4(mb_type)){
  599. if(IS_INTRA4x4(top_type)){
  600. h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4];
  601. h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5];
  602. h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6];
  603. h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3];
  604. }else{
  605. int pred;
  606. if(!top_type || (IS_INTER(top_type) && h->pps.constrained_intra_pred))
  607. pred= -1;
  608. else{
  609. pred= 2;
  610. }
  611. h->intra4x4_pred_mode_cache[4+8*0]=
  612. h->intra4x4_pred_mode_cache[5+8*0]=
  613. h->intra4x4_pred_mode_cache[6+8*0]=
  614. h->intra4x4_pred_mode_cache[7+8*0]= pred;
  615. }
  616. for(i=0; i<2; i++){
  617. if(IS_INTRA4x4(left_type[i])){
  618. h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]];
  619. h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]];
  620. }else{
  621. int pred;
  622. if(!left_type[i] || (IS_INTER(left_type[i]) && h->pps.constrained_intra_pred))
  623. pred= -1;
  624. else{
  625. pred= 2;
  626. }
  627. h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]=
  628. h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred;
  629. }
  630. }
  631. }
  632. }
  633. /*
  634. 0 . T T. T T T T
  635. 1 L . .L . . . .
  636. 2 L . .L . . . .
  637. 3 . T TL . . . .
  638. 4 L . .L . . . .
  639. 5 L . .. . . . .
  640. */
  641. //FIXME constraint_intra_pred & partitioning & nnz (lets hope this is just a typo in the spec)
  642. if(top_type){
  643. h->non_zero_count_cache[4+8*0]= h->non_zero_count[top_xy][4];
  644. h->non_zero_count_cache[5+8*0]= h->non_zero_count[top_xy][5];
  645. h->non_zero_count_cache[6+8*0]= h->non_zero_count[top_xy][6];
  646. h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3];
  647. h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][9];
  648. h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8];
  649. h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][12];
  650. h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11];
  651. }else{
  652. h->non_zero_count_cache[4+8*0]=
  653. h->non_zero_count_cache[5+8*0]=
  654. h->non_zero_count_cache[6+8*0]=
  655. h->non_zero_count_cache[7+8*0]=
  656. h->non_zero_count_cache[1+8*0]=
  657. h->non_zero_count_cache[2+8*0]=
  658. h->non_zero_count_cache[1+8*3]=
  659. h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;
  660. }
  661. for (i=0; i<2; i++) {
  662. if(left_type[i]){
  663. h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[0+2*i]];
  664. h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[1+2*i]];
  665. h->non_zero_count_cache[0+8*1 + 8*i]= h->non_zero_count[left_xy[i]][left_block[4+2*i]];
  666. h->non_zero_count_cache[0+8*4 + 8*i]= h->non_zero_count[left_xy[i]][left_block[5+2*i]];
  667. }else{
  668. h->non_zero_count_cache[3+8*1 + 2*8*i]=
  669. h->non_zero_count_cache[3+8*2 + 2*8*i]=
  670. h->non_zero_count_cache[0+8*1 + 8*i]=
  671. h->non_zero_count_cache[0+8*4 + 8*i]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;
  672. }
  673. }
  674. if( h->pps.cabac ) {
  675. // top_cbp
  676. if(top_type) {
  677. h->top_cbp = h->cbp_table[top_xy];
  678. } else if(IS_INTRA(mb_type)) {
  679. h->top_cbp = 0x1C0;
  680. } else {
  681. h->top_cbp = 0;
  682. }
  683. // left_cbp
  684. if (left_type[0]) {
  685. h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0;
  686. } else if(IS_INTRA(mb_type)) {
  687. h->left_cbp = 0x1C0;
  688. } else {
  689. h->left_cbp = 0;
  690. }
  691. if (left_type[0]) {
  692. h->left_cbp |= ((h->cbp_table[left_xy[0]]>>((left_block[0]&(~1))+1))&0x1) << 1;
  693. }
  694. if (left_type[1]) {
  695. h->left_cbp |= ((h->cbp_table[left_xy[1]]>>((left_block[2]&(~1))+1))&0x1) << 3;
  696. }
  697. }
  698. #if 1
  699. //FIXME direct mb can skip much of this
  700. if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){
  701. int list;
  702. for(list=0; list<1+(h->slice_type==B_TYPE); list++){
  703. if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){
  704. /*if(!h->mv_cache_clean[list]){
  705. memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all?
  706. memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t));
  707. h->mv_cache_clean[list]= 1;
  708. }*/
  709. continue;
  710. }
  711. h->mv_cache_clean[list]= 0;
  712. if(USES_LIST(top_type, list)){
  713. const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
  714. const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride;
  715. *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0];
  716. *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1];
  717. *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2];
  718. *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3];
  719. h->ref_cache[list][scan8[0] + 0 - 1*8]=
  720. h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0];
  721. h->ref_cache[list][scan8[0] + 2 - 1*8]=
  722. h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1];
  723. }else{
  724. *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]=
  725. *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]=
  726. *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]=
  727. *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0;
  728. *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101;
  729. }
  730. //FIXME unify cleanup or sth
  731. if(USES_LIST(left_type[0], list)){
  732. const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
  733. const int b8_xy= h->mb2b8_xy[left_xy[0]] + 1;
  734. *(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]];
  735. *(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]];
  736. h->ref_cache[list][scan8[0] - 1 + 0*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0]>>1)];
  737. h->ref_cache[list][scan8[0] - 1 + 1*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[1]>>1)];
  738. }else{
  739. *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 0*8]=
  740. *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 1*8]= 0;
  741. h->ref_cache[list][scan8[0] - 1 + 0*8]=
  742. h->ref_cache[list][scan8[0] - 1 + 1*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE;
  743. }
  744. if(USES_LIST(left_type[1], list)){
  745. const int b_xy= h->mb2b_xy[left_xy[1]] + 3;
  746. const int b8_xy= h->mb2b8_xy[left_xy[1]] + 1;
  747. *(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]];
  748. *(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]];
  749. h->ref_cache[list][scan8[0] - 1 + 2*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[2]>>1)];
  750. h->ref_cache[list][scan8[0] - 1 + 3*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[3]>>1)];
  751. }else{
  752. *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 2*8]=
  753. *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 3*8]= 0;
  754. h->ref_cache[list][scan8[0] - 1 + 2*8]=
  755. h->ref_cache[list][scan8[0] - 1 + 3*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE;
  756. assert((!left_type[0]) == (!left_type[1]));
  757. }
  758. if(for_deblock || (IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred))
  759. continue;
  760. if(USES_LIST(topleft_type, list)){
  761. const int b_xy = h->mb2b_xy[topleft_xy] + 3 + 3*h->b_stride;
  762. const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + h->b8_stride;
  763. *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];
  764. h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy];
  765. }else{
  766. *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= 0;
  767. h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
  768. }
  769. if(USES_LIST(topright_type, list)){
  770. const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride;
  771. const int b8_xy= h->mb2b8_xy[topright_xy] + h->b8_stride;
  772. *(uint32_t*)h->mv_cache[list][scan8[0] + 4 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];
  773. h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy];
  774. }else{
  775. *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0;
  776. h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
  777. }
  778. h->ref_cache[list][scan8[5 ]+1] =
  779. h->ref_cache[list][scan8[7 ]+1] =
  780. h->ref_cache[list][scan8[13]+1] = //FIXME remove past 3 (init somewhere else)
  781. h->ref_cache[list][scan8[4 ]] =
  782. h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE;
  783. *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]=
  784. *(uint32_t*)h->mv_cache [list][scan8[7 ]+1]=
  785. *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)
  786. *(uint32_t*)h->mv_cache [list][scan8[4 ]]=
  787. *(uint32_t*)h->mv_cache [list][scan8[12]]= 0;
  788. if( h->pps.cabac ) {
  789. /* XXX beurk, Load mvd */
  790. if(USES_LIST(top_type, list)){
  791. const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
  792. *(uint32_t*)h->mvd_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 0];
  793. *(uint32_t*)h->mvd_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 1];
  794. *(uint32_t*)h->mvd_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 2];
  795. *(uint32_t*)h->mvd_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 3];
  796. }else{
  797. *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]=
  798. *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]=
  799. *(uint32_t*)h->mvd_cache [list][scan8[0] + 2 - 1*8]=
  800. *(uint32_t*)h->mvd_cache [list][scan8[0] + 3 - 1*8]= 0;
  801. }
  802. if(USES_LIST(left_type[0], list)){
  803. const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
  804. *(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]];
  805. *(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]];
  806. }else{
  807. *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 0*8]=
  808. *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 1*8]= 0;
  809. }
  810. if(USES_LIST(left_type[1], list)){
  811. const int b_xy= h->mb2b_xy[left_xy[1]] + 3;
  812. *(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]];
  813. *(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]];
  814. }else{
  815. *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 2*8]=
  816. *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 3*8]= 0;
  817. }
  818. *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]=
  819. *(uint32_t*)h->mvd_cache [list][scan8[7 ]+1]=
  820. *(uint32_t*)h->mvd_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)
  821. *(uint32_t*)h->mvd_cache [list][scan8[4 ]]=
  822. *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0;
  823. if(h->slice_type == B_TYPE){
  824. fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1);
  825. if(IS_DIRECT(top_type)){
  826. *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101;
  827. }else if(IS_8X8(top_type)){
  828. int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride;
  829. h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy];
  830. h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1];
  831. }else{
  832. *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0;
  833. }
  834. if(IS_DIRECT(left_type[0]))
  835. h->direct_cache[scan8[0] - 1 + 0*8]= 1;
  836. else if(IS_8X8(left_type[0]))
  837. 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)];
  838. else
  839. h->direct_cache[scan8[0] - 1 + 0*8]= 0;
  840. if(IS_DIRECT(left_type[1]))
  841. h->direct_cache[scan8[0] - 1 + 2*8]= 1;
  842. else if(IS_8X8(left_type[1]))
  843. 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)];
  844. else
  845. h->direct_cache[scan8[0] - 1 + 2*8]= 0;
  846. }
  847. }
  848. if(FRAME_MBAFF){
  849. #define MAP_MVS\
  850. MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\
  851. MAP_F2F(scan8[0] + 0 - 1*8, top_type)\
  852. MAP_F2F(scan8[0] + 1 - 1*8, top_type)\
  853. MAP_F2F(scan8[0] + 2 - 1*8, top_type)\
  854. MAP_F2F(scan8[0] + 3 - 1*8, top_type)\
  855. MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\
  856. MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\
  857. MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\
  858. MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\
  859. MAP_F2F(scan8[0] - 1 + 3*8, left_type[1])
  860. if(MB_FIELD){
  861. #define MAP_F2F(idx, mb_type)\
  862. if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\
  863. h->ref_cache[list][idx] <<= 1;\
  864. h->mv_cache[list][idx][1] /= 2;\
  865. h->mvd_cache[list][idx][1] /= 2;\
  866. }
  867. MAP_MVS
  868. #undef MAP_F2F
  869. }else{
  870. #define MAP_F2F(idx, mb_type)\
  871. if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\
  872. h->ref_cache[list][idx] >>= 1;\
  873. h->mv_cache[list][idx][1] <<= 1;\
  874. h->mvd_cache[list][idx][1] <<= 1;\
  875. }
  876. MAP_MVS
  877. #undef MAP_F2F
  878. }
  879. }
  880. }
  881. }
  882. #endif
  883. h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]);
  884. }
  885. static inline void write_back_intra_pred_mode(H264Context *h){
  886. MpegEncContext * const s = &h->s;
  887. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  888. h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1];
  889. h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2];
  890. h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3];
  891. h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4];
  892. h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4];
  893. h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4];
  894. h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4];
  895. }
  896. /**
  897. * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
  898. */
  899. static inline int check_intra4x4_pred_mode(H264Context *h){
  900. MpegEncContext * const s = &h->s;
  901. static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};
  902. static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};
  903. int i;
  904. if(!(h->top_samples_available&0x8000)){
  905. for(i=0; i<4; i++){
  906. int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];
  907. if(status<0){
  908. 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);
  909. return -1;
  910. } else if(status){
  911. h->intra4x4_pred_mode_cache[scan8[0] + i]= status;
  912. }
  913. }
  914. }
  915. if(!(h->left_samples_available&0x8000)){
  916. for(i=0; i<4; i++){
  917. int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
  918. if(status<0){
  919. 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);
  920. return -1;
  921. } else if(status){
  922. h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
  923. }
  924. }
  925. }
  926. return 0;
  927. } //FIXME cleanup like next
  928. /**
  929. * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
  930. */
  931. static inline int check_intra_pred_mode(H264Context *h, int mode){
  932. MpegEncContext * const s = &h->s;
  933. static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};
  934. static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};
  935. if(mode < 0 || mode > 6) {
  936. 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);
  937. return -1;
  938. }
  939. if(!(h->top_samples_available&0x8000)){
  940. mode= top[ mode ];
  941. if(mode<0){
  942. 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);
  943. return -1;
  944. }
  945. }
  946. if(!(h->left_samples_available&0x8000)){
  947. mode= left[ mode ];
  948. if(mode<0){
  949. 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);
  950. return -1;
  951. }
  952. }
  953. return mode;
  954. }
  955. /**
  956. * gets the predicted intra4x4 prediction mode.
  957. */
  958. static inline int pred_intra_mode(H264Context *h, int n){
  959. const int index8= scan8[n];
  960. const int left= h->intra4x4_pred_mode_cache[index8 - 1];
  961. const int top = h->intra4x4_pred_mode_cache[index8 - 8];
  962. const int min= FFMIN(left, top);
  963. tprintf("mode:%d %d min:%d\n", left ,top, min);
  964. if(min<0) return DC_PRED;
  965. else return min;
  966. }
  967. static inline void write_back_non_zero_count(H264Context *h){
  968. MpegEncContext * const s = &h->s;
  969. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  970. h->non_zero_count[mb_xy][0]= h->non_zero_count_cache[7+8*1];
  971. h->non_zero_count[mb_xy][1]= h->non_zero_count_cache[7+8*2];
  972. h->non_zero_count[mb_xy][2]= h->non_zero_count_cache[7+8*3];
  973. h->non_zero_count[mb_xy][3]= h->non_zero_count_cache[7+8*4];
  974. h->non_zero_count[mb_xy][4]= h->non_zero_count_cache[4+8*4];
  975. h->non_zero_count[mb_xy][5]= h->non_zero_count_cache[5+8*4];
  976. h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4];
  977. h->non_zero_count[mb_xy][9]= h->non_zero_count_cache[1+8*2];
  978. h->non_zero_count[mb_xy][8]= h->non_zero_count_cache[2+8*2];
  979. h->non_zero_count[mb_xy][7]= h->non_zero_count_cache[2+8*1];
  980. h->non_zero_count[mb_xy][12]=h->non_zero_count_cache[1+8*5];
  981. h->non_zero_count[mb_xy][11]=h->non_zero_count_cache[2+8*5];
  982. h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4];
  983. if(FRAME_MBAFF){
  984. // store all luma nnzs, for deblocking
  985. int v = 0, i;
  986. for(i=0; i<16; i++)
  987. v += (!!h->non_zero_count_cache[scan8[i]]) << i;
  988. *(uint16_t*)&h->non_zero_count[mb_xy][14] = v;
  989. }
  990. }
  991. /**
  992. * gets the predicted number of non zero coefficients.
  993. * @param n block index
  994. */
  995. static inline int pred_non_zero_count(H264Context *h, int n){
  996. const int index8= scan8[n];
  997. const int left= h->non_zero_count_cache[index8 - 1];
  998. const int top = h->non_zero_count_cache[index8 - 8];
  999. int i= left + top;
  1000. if(i<64) i= (i+1)>>1;
  1001. tprintf("pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
  1002. return i&31;
  1003. }
  1004. static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){
  1005. const int topright_ref= h->ref_cache[list][ i - 8 + part_width ];
  1006. /* there is no consistent mapping of mvs to neighboring locations that will
  1007. * make mbaff happy, so we can't move all this logic to fill_caches */
  1008. if(FRAME_MBAFF){
  1009. MpegEncContext *s = &h->s;
  1010. const int *mb_types = s->current_picture_ptr->mb_type;
  1011. const int16_t *mv;
  1012. *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0;
  1013. *C = h->mv_cache[list][scan8[0]-2];
  1014. if(!MB_FIELD
  1015. && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){
  1016. int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3);
  1017. if(IS_INTERLACED(mb_types[topright_xy])){
  1018. #define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\
  1019. const int x4 = X4, y4 = Y4;\
  1020. const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\
  1021. if(!USES_LIST(mb_type,list) && !IS_8X8(mb_type))\
  1022. return LIST_NOT_USED;\
  1023. mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\
  1024. h->mv_cache[list][scan8[0]-2][0] = mv[0];\
  1025. h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\
  1026. return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP;
  1027. SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1);
  1028. }
  1029. }
  1030. if(topright_ref == PART_NOT_AVAILABLE
  1031. && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4
  1032. && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){
  1033. if(!MB_FIELD
  1034. && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){
  1035. SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1);
  1036. }
  1037. if(MB_FIELD
  1038. && !IS_INTERLACED(mb_types[h->left_mb_xy[0]])
  1039. && i >= scan8[0]+8){
  1040. // leftshift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's ok.
  1041. SET_DIAG_MV(>>1, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2);
  1042. }
  1043. }
  1044. #undef SET_DIAG_MV
  1045. }
  1046. if(topright_ref != PART_NOT_AVAILABLE){
  1047. *C= h->mv_cache[list][ i - 8 + part_width ];
  1048. return topright_ref;
  1049. }else{
  1050. tprintf("topright MV not available\n");
  1051. *C= h->mv_cache[list][ i - 8 - 1 ];
  1052. return h->ref_cache[list][ i - 8 - 1 ];
  1053. }
  1054. }
  1055. /**
  1056. * gets the predicted MV.
  1057. * @param n the block index
  1058. * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
  1059. * @param mx the x component of the predicted motion vector
  1060. * @param my the y component of the predicted motion vector
  1061. */
  1062. static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){
  1063. const int index8= scan8[n];
  1064. const int top_ref= h->ref_cache[list][ index8 - 8 ];
  1065. const int left_ref= h->ref_cache[list][ index8 - 1 ];
  1066. const int16_t * const A= h->mv_cache[list][ index8 - 1 ];
  1067. const int16_t * const B= h->mv_cache[list][ index8 - 8 ];
  1068. const int16_t * C;
  1069. int diagonal_ref, match_count;
  1070. assert(part_width==1 || part_width==2 || part_width==4);
  1071. /* mv_cache
  1072. B . . A T T T T
  1073. U . . L . . , .
  1074. U . . L . . . .
  1075. U . . L . . , .
  1076. . . . L . . . .
  1077. */
  1078. diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width);
  1079. match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref);
  1080. tprintf("pred_motion match_count=%d\n", match_count);
  1081. if(match_count > 1){ //most common
  1082. *mx= mid_pred(A[0], B[0], C[0]);
  1083. *my= mid_pred(A[1], B[1], C[1]);
  1084. }else if(match_count==1){
  1085. if(left_ref==ref){
  1086. *mx= A[0];
  1087. *my= A[1];
  1088. }else if(top_ref==ref){
  1089. *mx= B[0];
  1090. *my= B[1];
  1091. }else{
  1092. *mx= C[0];
  1093. *my= C[1];
  1094. }
  1095. }else{
  1096. if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){
  1097. *mx= A[0];
  1098. *my= A[1];
  1099. }else{
  1100. *mx= mid_pred(A[0], B[0], C[0]);
  1101. *my= mid_pred(A[1], B[1], C[1]);
  1102. }
  1103. }
  1104. 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);
  1105. }
  1106. /**
  1107. * gets the directionally predicted 16x8 MV.
  1108. * @param n the block index
  1109. * @param mx the x component of the predicted motion vector
  1110. * @param my the y component of the predicted motion vector
  1111. */
  1112. static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
  1113. if(n==0){
  1114. const int top_ref= h->ref_cache[list][ scan8[0] - 8 ];
  1115. const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ];
  1116. 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);
  1117. if(top_ref == ref){
  1118. *mx= B[0];
  1119. *my= B[1];
  1120. return;
  1121. }
  1122. }else{
  1123. const int left_ref= h->ref_cache[list][ scan8[8] - 1 ];
  1124. const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ];
  1125. 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);
  1126. if(left_ref == ref){
  1127. *mx= A[0];
  1128. *my= A[1];
  1129. return;
  1130. }
  1131. }
  1132. //RARE
  1133. pred_motion(h, n, 4, list, ref, mx, my);
  1134. }
  1135. /**
  1136. * gets the directionally predicted 8x16 MV.
  1137. * @param n the block index
  1138. * @param mx the x component of the predicted motion vector
  1139. * @param my the y component of the predicted motion vector
  1140. */
  1141. static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
  1142. if(n==0){
  1143. const int left_ref= h->ref_cache[list][ scan8[0] - 1 ];
  1144. const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ];
  1145. 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);
  1146. if(left_ref == ref){
  1147. *mx= A[0];
  1148. *my= A[1];
  1149. return;
  1150. }
  1151. }else{
  1152. const int16_t * C;
  1153. int diagonal_ref;
  1154. diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2);
  1155. 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);
  1156. if(diagonal_ref == ref){
  1157. *mx= C[0];
  1158. *my= C[1];
  1159. return;
  1160. }
  1161. }
  1162. //RARE
  1163. pred_motion(h, n, 2, list, ref, mx, my);
  1164. }
  1165. static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){
  1166. const int top_ref = h->ref_cache[0][ scan8[0] - 8 ];
  1167. const int left_ref= h->ref_cache[0][ scan8[0] - 1 ];
  1168. tprintf("pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y);
  1169. if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE
  1170. || (top_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0)
  1171. || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){
  1172. *mx = *my = 0;
  1173. return;
  1174. }
  1175. pred_motion(h, 0, 4, 0, 0, mx, my);
  1176. return;
  1177. }
  1178. static inline void direct_dist_scale_factor(H264Context * const h){
  1179. const int poc = h->s.current_picture_ptr->poc;
  1180. const int poc1 = h->ref_list[1][0].poc;
  1181. int i;
  1182. for(i=0; i<h->ref_count[0]; i++){
  1183. int poc0 = h->ref_list[0][i].poc;
  1184. int td = clip(poc1 - poc0, -128, 127);
  1185. if(td == 0 /* FIXME || pic0 is a long-term ref */){
  1186. h->dist_scale_factor[i] = 256;
  1187. }else{
  1188. int tb = clip(poc - poc0, -128, 127);
  1189. int tx = (16384 + (ABS(td) >> 1)) / td;
  1190. h->dist_scale_factor[i] = clip((tb*tx + 32) >> 6, -1024, 1023);
  1191. }
  1192. }
  1193. if(FRAME_MBAFF){
  1194. for(i=0; i<h->ref_count[0]; i++){
  1195. h->dist_scale_factor_field[2*i] =
  1196. h->dist_scale_factor_field[2*i+1] = h->dist_scale_factor[i];
  1197. }
  1198. }
  1199. }
  1200. static inline void direct_ref_list_init(H264Context * const h){
  1201. MpegEncContext * const s = &h->s;
  1202. Picture * const ref1 = &h->ref_list[1][0];
  1203. Picture * const cur = s->current_picture_ptr;
  1204. int list, i, j;
  1205. if(cur->pict_type == I_TYPE)
  1206. cur->ref_count[0] = 0;
  1207. if(cur->pict_type != B_TYPE)
  1208. cur->ref_count[1] = 0;
  1209. for(list=0; list<2; list++){
  1210. cur->ref_count[list] = h->ref_count[list];
  1211. for(j=0; j<h->ref_count[list]; j++)
  1212. cur->ref_poc[list][j] = h->ref_list[list][j].poc;
  1213. }
  1214. if(cur->pict_type != B_TYPE || h->direct_spatial_mv_pred)
  1215. return;
  1216. for(list=0; list<2; list++){
  1217. for(i=0; i<ref1->ref_count[list]; i++){
  1218. const int poc = ref1->ref_poc[list][i];
  1219. h->map_col_to_list0[list][i] = 0; /* bogus; fills in for missing frames */
  1220. for(j=0; j<h->ref_count[list]; j++)
  1221. if(h->ref_list[list][j].poc == poc){
  1222. h->map_col_to_list0[list][i] = j;
  1223. break;
  1224. }
  1225. }
  1226. }
  1227. if(FRAME_MBAFF){
  1228. for(list=0; list<2; list++){
  1229. for(i=0; i<ref1->ref_count[list]; i++){
  1230. j = h->map_col_to_list0[list][i];
  1231. h->map_col_to_list0_field[list][2*i] = 2*j;
  1232. h->map_col_to_list0_field[list][2*i+1] = 2*j+1;
  1233. }
  1234. }
  1235. }
  1236. }
  1237. static inline void pred_direct_motion(H264Context * const h, int *mb_type){
  1238. MpegEncContext * const s = &h->s;
  1239. const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
  1240. const int b8_xy = 2*s->mb_x + 2*s->mb_y*h->b8_stride;
  1241. const int b4_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
  1242. const int mb_type_col = h->ref_list[1][0].mb_type[mb_xy];
  1243. const int16_t (*l1mv0)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[0][b4_xy];
  1244. const int16_t (*l1mv1)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[1][b4_xy];
  1245. const int8_t *l1ref0 = &h->ref_list[1][0].ref_index[0][b8_xy];
  1246. const int8_t *l1ref1 = &h->ref_list[1][0].ref_index[1][b8_xy];
  1247. const int is_b8x8 = IS_8X8(*mb_type);
  1248. int sub_mb_type;
  1249. int i8, i4;
  1250. #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)
  1251. if(IS_8X8(mb_type_col) && !h->sps.direct_8x8_inference_flag){
  1252. /* FIXME save sub mb types from previous frames (or derive from MVs)
  1253. * so we know exactly what block size to use */
  1254. sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */
  1255. *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1;
  1256. }else if(!is_b8x8 && (mb_type_col & MB_TYPE_16x16_OR_INTRA)){
  1257. sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
  1258. *mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */
  1259. }else{
  1260. sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
  1261. *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1;
  1262. }
  1263. if(!is_b8x8)
  1264. *mb_type |= MB_TYPE_DIRECT2;
  1265. if(MB_FIELD)
  1266. *mb_type |= MB_TYPE_INTERLACED;
  1267. 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);
  1268. if(h->direct_spatial_mv_pred){
  1269. int ref[2];
  1270. int mv[2][2];
  1271. int list;
  1272. /* FIXME interlacing + spatial direct uses wrong colocated block positions */
  1273. /* ref = min(neighbors) */
  1274. for(list=0; list<2; list++){
  1275. int refa = h->ref_cache[list][scan8[0] - 1];
  1276. int refb = h->ref_cache[list][scan8[0] - 8];
  1277. int refc = h->ref_cache[list][scan8[0] - 8 + 4];
  1278. if(refc == -2)
  1279. refc = h->ref_cache[list][scan8[0] - 8 - 1];
  1280. ref[list] = refa;
  1281. if(ref[list] < 0 || (refb < ref[list] && refb >= 0))
  1282. ref[list] = refb;
  1283. if(ref[list] < 0 || (refc < ref[list] && refc >= 0))
  1284. ref[list] = refc;
  1285. if(ref[list] < 0)
  1286. ref[list] = -1;
  1287. }
  1288. if(ref[0] < 0 && ref[1] < 0){
  1289. ref[0] = ref[1] = 0;
  1290. mv[0][0] = mv[0][1] =
  1291. mv[1][0] = mv[1][1] = 0;
  1292. }else{
  1293. for(list=0; list<2; list++){
  1294. if(ref[list] >= 0)
  1295. pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]);
  1296. else
  1297. mv[list][0] = mv[list][1] = 0;
  1298. }
  1299. }
  1300. if(ref[1] < 0){
  1301. *mb_type &= ~MB_TYPE_P0L1;
  1302. sub_mb_type &= ~MB_TYPE_P0L1;
  1303. }else if(ref[0] < 0){
  1304. *mb_type &= ~MB_TYPE_P0L0;
  1305. sub_mb_type &= ~MB_TYPE_P0L0;
  1306. }
  1307. if(IS_16X16(*mb_type)){
  1308. fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);
  1309. fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);
  1310. if(!IS_INTRA(mb_type_col)
  1311. && ( (l1ref0[0] == 0 && ABS(l1mv0[0][0]) <= 1 && ABS(l1mv0[0][1]) <= 1)
  1312. || (l1ref0[0] < 0 && l1ref1[0] == 0 && ABS(l1mv1[0][0]) <= 1 && ABS(l1mv1[0][1]) <= 1
  1313. && (h->x264_build>33 || !h->x264_build)))){
  1314. if(ref[0] > 0)
  1315. fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4);
  1316. else
  1317. fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4);
  1318. if(ref[1] > 0)
  1319. fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4);
  1320. else
  1321. fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, 0, 4);
  1322. }else{
  1323. fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4);
  1324. fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4);
  1325. }
  1326. }else{
  1327. for(i8=0; i8<4; i8++){
  1328. const int x8 = i8&1;
  1329. const int y8 = i8>>1;
  1330. if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
  1331. continue;
  1332. h->sub_mb_type[i8] = sub_mb_type;
  1333. fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4);
  1334. fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mv[1][0],mv[1][1]), 4);
  1335. fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);
  1336. fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);
  1337. /* col_zero_flag */
  1338. if(!IS_INTRA(mb_type_col) && ( l1ref0[x8 + y8*h->b8_stride] == 0
  1339. || (l1ref0[x8 + y8*h->b8_stride] < 0 && l1ref1[x8 + y8*h->b8_stride] == 0
  1340. && (h->x264_build>33 || !h->x264_build)))){
  1341. const int16_t (*l1mv)[2]= l1ref0[x8 + y8*h->b8_stride] == 0 ? l1mv0 : l1mv1;
  1342. if(IS_SUB_8X8(sub_mb_type)){
  1343. const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride];
  1344. if(ABS(mv_col[0]) <= 1 && ABS(mv_col[1]) <= 1){
  1345. if(ref[0] == 0)
  1346. fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
  1347. if(ref[1] == 0)
  1348. fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
  1349. }
  1350. }else
  1351. for(i4=0; i4<4; i4++){
  1352. const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride];
  1353. if(ABS(mv_col[0]) <= 1 && ABS(mv_col[1]) <= 1){
  1354. if(ref[0] == 0)
  1355. *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0;
  1356. if(ref[1] == 0)
  1357. *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0;
  1358. }
  1359. }
  1360. }
  1361. }
  1362. }
  1363. }else{ /* direct temporal mv pred */
  1364. const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]};
  1365. const int *dist_scale_factor = h->dist_scale_factor;
  1366. if(FRAME_MBAFF){
  1367. if(IS_INTERLACED(*mb_type)){
  1368. map_col_to_list0[0] = h->map_col_to_list0_field[0];
  1369. map_col_to_list0[1] = h->map_col_to_list0_field[1];
  1370. dist_scale_factor = h->dist_scale_factor_field;
  1371. }
  1372. if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col)){
  1373. /* FIXME assumes direct_8x8_inference == 1 */
  1374. const int pair_xy = s->mb_x + (s->mb_y&~1)*s->mb_stride;
  1375. int mb_types_col[2];
  1376. int y_shift;
  1377. *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1
  1378. | (is_b8x8 ? 0 : MB_TYPE_DIRECT2)
  1379. | (*mb_type & MB_TYPE_INTERLACED);
  1380. sub_mb_type = MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_16x16;
  1381. if(IS_INTERLACED(*mb_type)){
  1382. /* frame to field scaling */
  1383. mb_types_col[0] = h->ref_list[1][0].mb_type[pair_xy];
  1384. mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride];
  1385. if(s->mb_y&1){
  1386. l1ref0 -= 2*h->b8_stride;
  1387. l1ref1 -= 2*h->b8_stride;
  1388. l1mv0 -= 4*h->b_stride;
  1389. l1mv1 -= 4*h->b_stride;
  1390. }
  1391. y_shift = 0;
  1392. if( (mb_types_col[0] & MB_TYPE_16x16_OR_INTRA)
  1393. && (mb_types_col[1] & MB_TYPE_16x16_OR_INTRA)
  1394. && !is_b8x8)
  1395. *mb_type |= MB_TYPE_16x8;
  1396. else
  1397. *mb_type |= MB_TYPE_8x8;
  1398. }else{
  1399. /* field to frame scaling */
  1400. /* col_mb_y = (mb_y&~1) + (topAbsDiffPOC < bottomAbsDiffPOC ? 0 : 1)
  1401. * but in MBAFF, top and bottom POC are equal */
  1402. int dy = (s->mb_y&1) ? 1 : 2;
  1403. mb_types_col[0] =
  1404. mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride];
  1405. l1ref0 += dy*h->b8_stride;
  1406. l1ref1 += dy*h->b8_stride;
  1407. l1mv0 += 2*dy*h->b_stride;
  1408. l1mv1 += 2*dy*h->b_stride;
  1409. y_shift = 2;
  1410. if((mb_types_col[0] & (MB_TYPE_16x16_OR_INTRA|MB_TYPE_16x8))
  1411. && !is_b8x8)
  1412. *mb_type |= MB_TYPE_16x16;
  1413. else
  1414. *mb_type |= MB_TYPE_8x8;
  1415. }
  1416. for(i8=0; i8<4; i8++){
  1417. const int x8 = i8&1;
  1418. const int y8 = i8>>1;
  1419. int ref0, scale;
  1420. const int16_t (*l1mv)[2]= l1mv0;
  1421. if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
  1422. continue;
  1423. h->sub_mb_type[i8] = sub_mb_type;
  1424. fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);
  1425. if(IS_INTRA(mb_types_col[y8])){
  1426. fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);
  1427. fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
  1428. fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
  1429. continue;
  1430. }
  1431. ref0 = l1ref0[x8 + (y8*2>>y_shift)*h->b8_stride];
  1432. if(ref0 >= 0)
  1433. ref0 = map_col_to_list0[0][ref0*2>>y_shift];
  1434. else{
  1435. ref0 = map_col_to_list0[1][l1ref1[x8 + (y8*2>>y_shift)*h->b8_stride]*2>>y_shift];
  1436. l1mv= l1mv1;
  1437. }
  1438. scale = dist_scale_factor[ref0];
  1439. fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);
  1440. {
  1441. const int16_t *mv_col = l1mv[x8*3 + (y8*6>>y_shift)*h->b_stride];
  1442. int my_col = (mv_col[1]<<y_shift)/2;
  1443. int mx = (scale * mv_col[0] + 128) >> 8;
  1444. int my = (scale * my_col + 128) >> 8;
  1445. fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);
  1446. fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4);
  1447. }
  1448. }
  1449. return;
  1450. }
  1451. }
  1452. /* one-to-one mv scaling */
  1453. if(IS_16X16(*mb_type)){
  1454. fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1);
  1455. if(IS_INTRA(mb_type_col)){
  1456. fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);
  1457. fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, 0, 4);
  1458. fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, 0, 4);
  1459. }else{
  1460. const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0]]
  1461. : map_col_to_list0[1][l1ref1[0]];
  1462. const int scale = dist_scale_factor[ref0];
  1463. const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0];
  1464. int mv_l0[2];
  1465. mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
  1466. mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
  1467. fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref0, 1);
  1468. fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0],mv_l0[1]), 4);
  1469. 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);
  1470. }
  1471. }else{
  1472. for(i8=0; i8<4; i8++){
  1473. const int x8 = i8&1;
  1474. const int y8 = i8>>1;
  1475. int ref0, scale;
  1476. const int16_t (*l1mv)[2]= l1mv0;
  1477. if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
  1478. continue;
  1479. h->sub_mb_type[i8] = sub_mb_type;
  1480. fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);
  1481. if(IS_INTRA(mb_type_col)){
  1482. fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);
  1483. fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
  1484. fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
  1485. continue;
  1486. }
  1487. ref0 = l1ref0[x8 + y8*h->b8_stride];
  1488. if(ref0 >= 0)
  1489. ref0 = map_col_to_list0[0][ref0];
  1490. else{
  1491. ref0 = map_col_to_list0[1][l1ref1[x8 + y8*h->b8_stride]];
  1492. l1mv= l1mv1;
  1493. }
  1494. scale = dist_scale_factor[ref0];
  1495. fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);
  1496. if(IS_SUB_8X8(sub_mb_type)){
  1497. const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride];
  1498. int mx = (scale * mv_col[0] + 128) >> 8;
  1499. int my = (scale * mv_col[1] + 128) >> 8;
  1500. fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);
  1501. fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4);
  1502. }else
  1503. for(i4=0; i4<4; i4++){
  1504. const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride];
  1505. int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]];
  1506. mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
  1507. mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
  1508. *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] =
  1509. pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]);
  1510. }
  1511. }
  1512. }
  1513. }
  1514. }
  1515. static inline void write_back_motion(H264Context *h, int mb_type){
  1516. MpegEncContext * const s = &h->s;
  1517. const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
  1518. const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride;
  1519. int list;
  1520. if(!USES_LIST(mb_type, 0))
  1521. fill_rectangle(&s->current_picture.ref_index[0][b8_xy], 2, 2, h->b8_stride, (uint8_t)LIST_NOT_USED, 1);
  1522. for(list=0; list<2; list++){
  1523. int y;
  1524. if(!USES_LIST(mb_type, list))
  1525. continue;
  1526. for(y=0; y<4; y++){
  1527. *(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];
  1528. *(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];
  1529. }
  1530. if( h->pps.cabac ) {
  1531. for(y=0; y<4; y++){
  1532. *(uint64_t*)h->mvd_table[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+0 + 8*y];
  1533. *(uint64_t*)h->mvd_table[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+2 + 8*y];
  1534. }
  1535. }
  1536. {
  1537. uint8_t *ref_index = &s->current_picture.ref_index[list][b8_xy];
  1538. ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]];
  1539. ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]];
  1540. ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]];
  1541. ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]];
  1542. }
  1543. }
  1544. if(h->slice_type == B_TYPE && h->pps.cabac){
  1545. if(IS_8X8(mb_type)){
  1546. uint8_t *direct_table = &h->direct_table[b8_xy];
  1547. direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0;
  1548. direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0;
  1549. direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0;
  1550. }
  1551. }
  1552. }
  1553. /**
  1554. * Decodes a network abstraction layer unit.
  1555. * @param consumed is the number of bytes used as input
  1556. * @param length is the length of the array
  1557. * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing?
  1558. * @returns decoded bytes, might be src+1 if no escapes
  1559. */
  1560. static uint8_t *decode_nal(H264Context *h, uint8_t *src, int *dst_length, int *consumed, int length){
  1561. int i, si, di;
  1562. uint8_t *dst;
  1563. // src[0]&0x80; //forbidden bit
  1564. h->nal_ref_idc= src[0]>>5;
  1565. h->nal_unit_type= src[0]&0x1F;
  1566. src++; length--;
  1567. #if 0
  1568. for(i=0; i<length; i++)
  1569. printf("%2X ", src[i]);
  1570. #endif
  1571. for(i=0; i+1<length; i+=2){
  1572. if(src[i]) continue;
  1573. if(i>0 && src[i-1]==0) i--;
  1574. if(i+2<length && src[i+1]==0 && src[i+2]<=3){
  1575. if(src[i+2]!=3){
  1576. /* startcode, so we must be past the end */
  1577. length=i;
  1578. }
  1579. break;
  1580. }
  1581. }
  1582. if(i>=length-1){ //no escaped 0
  1583. *dst_length= length;
  1584. *consumed= length+1; //+1 for the header
  1585. return src;
  1586. }
  1587. h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length);
  1588. dst= h->rbsp_buffer;
  1589. //printf("decoding esc\n");
  1590. si=di=0;
  1591. while(si<length){
  1592. //remove escapes (very rare 1:2^22)
  1593. if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){
  1594. if(src[si+2]==3){ //escape
  1595. dst[di++]= 0;
  1596. dst[di++]= 0;
  1597. si+=3;
  1598. continue;
  1599. }else //next start code
  1600. break;
  1601. }
  1602. dst[di++]= src[si++];
  1603. }
  1604. *dst_length= di;
  1605. *consumed= si + 1;//+1 for the header
  1606. //FIXME store exact number of bits in the getbitcontext (its needed for decoding)
  1607. return dst;
  1608. }
  1609. #if 0
  1610. /**
  1611. * @param src the data which should be escaped
  1612. * @param dst the target buffer, dst+1 == src is allowed as a special case
  1613. * @param length the length of the src data
  1614. * @param dst_length the length of the dst array
  1615. * @returns length of escaped data in bytes or -1 if an error occured
  1616. */
  1617. static int encode_nal(H264Context *h, uint8_t *dst, uint8_t *src, int length, int dst_length){
  1618. int i, escape_count, si, di;
  1619. uint8_t *temp;
  1620. assert(length>=0);
  1621. assert(dst_length>0);
  1622. dst[0]= (h->nal_ref_idc<<5) + h->nal_unit_type;
  1623. if(length==0) return 1;
  1624. escape_count= 0;
  1625. for(i=0; i<length; i+=2){
  1626. if(src[i]) continue;
  1627. if(i>0 && src[i-1]==0)
  1628. i--;
  1629. if(i+2<length && src[i+1]==0 && src[i+2]<=3){
  1630. escape_count++;
  1631. i+=2;
  1632. }
  1633. }
  1634. if(escape_count==0){
  1635. if(dst+1 != src)
  1636. memcpy(dst+1, src, length);
  1637. return length + 1;
  1638. }
  1639. if(length + escape_count + 1> dst_length)
  1640. return -1;
  1641. //this should be damn rare (hopefully)
  1642. h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length + escape_count);
  1643. temp= h->rbsp_buffer;
  1644. //printf("encoding esc\n");
  1645. si= 0;
  1646. di= 0;
  1647. while(si < length){
  1648. if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){
  1649. temp[di++]= 0; si++;
  1650. temp[di++]= 0; si++;
  1651. temp[di++]= 3;
  1652. temp[di++]= src[si++];
  1653. }
  1654. else
  1655. temp[di++]= src[si++];
  1656. }
  1657. memcpy(dst+1, temp, length+escape_count);
  1658. assert(di == length+escape_count);
  1659. return di + 1;
  1660. }
  1661. /**
  1662. * write 1,10,100,1000,... for alignment, yes its exactly inverse to mpeg4
  1663. */
  1664. static void encode_rbsp_trailing(PutBitContext *pb){
  1665. int length;
  1666. put_bits(pb, 1, 1);
  1667. length= (-put_bits_count(pb))&7;
  1668. if(length) put_bits(pb, length, 0);
  1669. }
  1670. #endif
  1671. /**
  1672. * identifies the exact end of the bitstream
  1673. * @return the length of the trailing, or 0 if damaged
  1674. */
  1675. static int decode_rbsp_trailing(uint8_t *src){
  1676. int v= *src;
  1677. int r;
  1678. tprintf("rbsp trailing %X\n", v);
  1679. for(r=1; r<9; r++){
  1680. if(v&1) return r;
  1681. v>>=1;
  1682. }
  1683. return 0;
  1684. }
  1685. /**
  1686. * idct tranforms the 16 dc values and dequantize them.
  1687. * @param qp quantization parameter
  1688. */
  1689. static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
  1690. #define stride 16
  1691. int i;
  1692. int temp[16]; //FIXME check if this is a good idea
  1693. static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};
  1694. static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
  1695. //memset(block, 64, 2*256);
  1696. //return;
  1697. for(i=0; i<4; i++){
  1698. const int offset= y_offset[i];
  1699. const int z0= block[offset+stride*0] + block[offset+stride*4];
  1700. const int z1= block[offset+stride*0] - block[offset+stride*4];
  1701. const int z2= block[offset+stride*1] - block[offset+stride*5];
  1702. const int z3= block[offset+stride*1] + block[offset+stride*5];
  1703. temp[4*i+0]= z0+z3;
  1704. temp[4*i+1]= z1+z2;
  1705. temp[4*i+2]= z1-z2;
  1706. temp[4*i+3]= z0-z3;
  1707. }
  1708. for(i=0; i<4; i++){
  1709. const int offset= x_offset[i];
  1710. const int z0= temp[4*0+i] + temp[4*2+i];
  1711. const int z1= temp[4*0+i] - temp[4*2+i];
  1712. const int z2= temp[4*1+i] - temp[4*3+i];
  1713. const int z3= temp[4*1+i] + temp[4*3+i];
  1714. block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_resdual
  1715. block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8));
  1716. block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8));
  1717. block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8));
  1718. }
  1719. }
  1720. #if 0
  1721. /**
  1722. * dct tranforms the 16 dc values.
  1723. * @param qp quantization parameter ??? FIXME
  1724. */
  1725. static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){
  1726. // const int qmul= dequant_coeff[qp][0];
  1727. int i;
  1728. int temp[16]; //FIXME check if this is a good idea
  1729. static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};
  1730. static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
  1731. for(i=0; i<4; i++){
  1732. const int offset= y_offset[i];
  1733. const int z0= block[offset+stride*0] + block[offset+stride*4];
  1734. const int z1= block[offset+stride*0] - block[offset+stride*4];
  1735. const int z2= block[offset+stride*1] - block[offset+stride*5];
  1736. const int z3= block[offset+stride*1] + block[offset+stride*5];
  1737. temp[4*i+0]= z0+z3;
  1738. temp[4*i+1]= z1+z2;
  1739. temp[4*i+2]= z1-z2;
  1740. temp[4*i+3]= z0-z3;
  1741. }
  1742. for(i=0; i<4; i++){
  1743. const int offset= x_offset[i];
  1744. const int z0= temp[4*0+i] + temp[4*2+i];
  1745. const int z1= temp[4*0+i] - temp[4*2+i];
  1746. const int z2= temp[4*1+i] - temp[4*3+i];
  1747. const int z3= temp[4*1+i] + temp[4*3+i];
  1748. block[stride*0 +offset]= (z0 + z3)>>1;
  1749. block[stride*2 +offset]= (z1 + z2)>>1;
  1750. block[stride*8 +offset]= (z1 - z2)>>1;
  1751. block[stride*10+offset]= (z0 - z3)>>1;
  1752. }
  1753. }
  1754. #endif
  1755. #undef xStride
  1756. #undef stride
  1757. static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
  1758. const int stride= 16*2;
  1759. const int xStride= 16;
  1760. int a,b,c,d,e;
  1761. a= block[stride*0 + xStride*0];
  1762. b= block[stride*0 + xStride*1];
  1763. c= block[stride*1 + xStride*0];
  1764. d= block[stride*1 + xStride*1];
  1765. e= a-b;
  1766. a= a+b;
  1767. b= c-d;
  1768. c= c+d;
  1769. block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7;
  1770. block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7;
  1771. block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7;
  1772. block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7;
  1773. }
  1774. #if 0
  1775. static void chroma_dc_dct_c(DCTELEM *block){
  1776. const int stride= 16*2;
  1777. const int xStride= 16;
  1778. int a,b,c,d,e;
  1779. a= block[stride*0 + xStride*0];
  1780. b= block[stride*0 + xStride*1];
  1781. c= block[stride*1 + xStride*0];
  1782. d= block[stride*1 + xStride*1];
  1783. e= a-b;
  1784. a= a+b;
  1785. b= c-d;
  1786. c= c+d;
  1787. block[stride*0 + xStride*0]= (a+c);
  1788. block[stride*0 + xStride*1]= (e+b);
  1789. block[stride*1 + xStride*0]= (a-c);
  1790. block[stride*1 + xStride*1]= (e-b);
  1791. }
  1792. #endif
  1793. /**
  1794. * gets the chroma qp.
  1795. */
  1796. static inline int get_chroma_qp(int chroma_qp_index_offset, int qscale){
  1797. return chroma_qp[clip(qscale + chroma_qp_index_offset, 0, 51)];
  1798. }
  1799. #if 0
  1800. static void h264_diff_dct_c(DCTELEM *block, uint8_t *src1, uint8_t *src2, int stride){
  1801. int i;
  1802. //FIXME try int temp instead of block
  1803. for(i=0; i<4; i++){
  1804. const int d0= src1[0 + i*stride] - src2[0 + i*stride];
  1805. const int d1= src1[1 + i*stride] - src2[1 + i*stride];
  1806. const int d2= src1[2 + i*stride] - src2[2 + i*stride];
  1807. const int d3= src1[3 + i*stride] - src2[3 + i*stride];
  1808. const int z0= d0 + d3;
  1809. const int z3= d0 - d3;
  1810. const int z1= d1 + d2;
  1811. const int z2= d1 - d2;
  1812. block[0 + 4*i]= z0 + z1;
  1813. block[1 + 4*i]= 2*z3 + z2;
  1814. block[2 + 4*i]= z0 - z1;
  1815. block[3 + 4*i]= z3 - 2*z2;
  1816. }
  1817. for(i=0; i<4; i++){
  1818. const int z0= block[0*4 + i] + block[3*4 + i];
  1819. const int z3= block[0*4 + i] - block[3*4 + i];
  1820. const int z1= block[1*4 + i] + block[2*4 + i];
  1821. const int z2= block[1*4 + i] - block[2*4 + i];
  1822. block[0*4 + i]= z0 + z1;
  1823. block[1*4 + i]= 2*z3 + z2;
  1824. block[2*4 + i]= z0 - z1;
  1825. block[3*4 + i]= z3 - 2*z2;
  1826. }
  1827. }
  1828. #endif
  1829. //FIXME need to check that this doesnt overflow signed 32 bit for low qp, i am not sure, it's very close
  1830. //FIXME check that gcc inlines this (and optimizes intra & seperate_dc stuff away)
  1831. static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int seperate_dc){
  1832. int i;
  1833. const int * const quant_table= quant_coeff[qscale];
  1834. const int bias= intra ? (1<<QUANT_SHIFT)/3 : (1<<QUANT_SHIFT)/6;
  1835. const unsigned int threshold1= (1<<QUANT_SHIFT) - bias - 1;
  1836. const unsigned int threshold2= (threshold1<<1);
  1837. int last_non_zero;
  1838. if(seperate_dc){
  1839. if(qscale<=18){
  1840. //avoid overflows
  1841. const int dc_bias= intra ? (1<<(QUANT_SHIFT-2))/3 : (1<<(QUANT_SHIFT-2))/6;
  1842. const unsigned int dc_threshold1= (1<<(QUANT_SHIFT-2)) - dc_bias - 1;
  1843. const unsigned int dc_threshold2= (dc_threshold1<<1);
  1844. int level= block[0]*quant_coeff[qscale+18][0];
  1845. if(((unsigned)(level+dc_threshold1))>dc_threshold2){
  1846. if(level>0){
  1847. level= (dc_bias + level)>>(QUANT_SHIFT-2);
  1848. block[0]= level;
  1849. }else{
  1850. level= (dc_bias - level)>>(QUANT_SHIFT-2);
  1851. block[0]= -level;
  1852. }
  1853. // last_non_zero = i;
  1854. }else{
  1855. block[0]=0;
  1856. }
  1857. }else{
  1858. const int dc_bias= intra ? (1<<(QUANT_SHIFT+1))/3 : (1<<(QUANT_SHIFT+1))/6;
  1859. const unsigned int dc_threshold1= (1<<(QUANT_SHIFT+1)) - dc_bias - 1;
  1860. const unsigned int dc_threshold2= (dc_threshold1<<1);
  1861. int level= block[0]*quant_table[0];
  1862. if(((unsigned)(level+dc_threshold1))>dc_threshold2){
  1863. if(level>0){
  1864. level= (dc_bias + level)>>(QUANT_SHIFT+1);
  1865. block[0]= level;
  1866. }else{
  1867. level= (dc_bias - level)>>(QUANT_SHIFT+1);
  1868. block[0]= -level;
  1869. }
  1870. // last_non_zero = i;
  1871. }else{
  1872. block[0]=0;
  1873. }
  1874. }
  1875. last_non_zero= 0;
  1876. i=1;
  1877. }else{
  1878. last_non_zero= -1;
  1879. i=0;
  1880. }
  1881. for(; i<16; i++){
  1882. const int j= scantable[i];
  1883. int level= block[j]*quant_table[j];
  1884. // if( bias+level >= (1<<(QMAT_SHIFT - 3))
  1885. // || bias-level >= (1<<(QMAT_SHIFT - 3))){
  1886. if(((unsigned)(level+threshold1))>threshold2){
  1887. if(level>0){
  1888. level= (bias + level)>>QUANT_SHIFT;
  1889. block[j]= level;
  1890. }else{
  1891. level= (bias - level)>>QUANT_SHIFT;
  1892. block[j]= -level;
  1893. }
  1894. last_non_zero = i;
  1895. }else{
  1896. block[j]=0;
  1897. }
  1898. }
  1899. return last_non_zero;
  1900. }
  1901. static void pred4x4_vertical_c(uint8_t *src, uint8_t *topright, int stride){
  1902. const uint32_t a= ((uint32_t*)(src-stride))[0];
  1903. ((uint32_t*)(src+0*stride))[0]= a;
  1904. ((uint32_t*)(src+1*stride))[0]= a;
  1905. ((uint32_t*)(src+2*stride))[0]= a;
  1906. ((uint32_t*)(src+3*stride))[0]= a;
  1907. }
  1908. static void pred4x4_horizontal_c(uint8_t *src, uint8_t *topright, int stride){
  1909. ((uint32_t*)(src+0*stride))[0]= src[-1+0*stride]*0x01010101;
  1910. ((uint32_t*)(src+1*stride))[0]= src[-1+1*stride]*0x01010101;
  1911. ((uint32_t*)(src+2*stride))[0]= src[-1+2*stride]*0x01010101;
  1912. ((uint32_t*)(src+3*stride))[0]= src[-1+3*stride]*0x01010101;
  1913. }
  1914. static void pred4x4_dc_c(uint8_t *src, uint8_t *topright, int stride){
  1915. const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride]
  1916. + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3;
  1917. ((uint32_t*)(src+0*stride))[0]=
  1918. ((uint32_t*)(src+1*stride))[0]=
  1919. ((uint32_t*)(src+2*stride))[0]=
  1920. ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;
  1921. }
  1922. static void pred4x4_left_dc_c(uint8_t *src, uint8_t *topright, int stride){
  1923. const int dc= ( src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2;
  1924. ((uint32_t*)(src+0*stride))[0]=
  1925. ((uint32_t*)(src+1*stride))[0]=
  1926. ((uint32_t*)(src+2*stride))[0]=
  1927. ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;
  1928. }
  1929. static void pred4x4_top_dc_c(uint8_t *src, uint8_t *topright, int stride){
  1930. const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2;
  1931. ((uint32_t*)(src+0*stride))[0]=
  1932. ((uint32_t*)(src+1*stride))[0]=
  1933. ((uint32_t*)(src+2*stride))[0]=
  1934. ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;
  1935. }
  1936. static void pred4x4_128_dc_c(uint8_t *src, uint8_t *topright, int stride){
  1937. ((uint32_t*)(src+0*stride))[0]=
  1938. ((uint32_t*)(src+1*stride))[0]=
  1939. ((uint32_t*)(src+2*stride))[0]=
  1940. ((uint32_t*)(src+3*stride))[0]= 128U*0x01010101U;
  1941. }
  1942. #define LOAD_TOP_RIGHT_EDGE\
  1943. const int t4= topright[0];\
  1944. const int t5= topright[1];\
  1945. const int t6= topright[2];\
  1946. const int t7= topright[3];\
  1947. #define LOAD_LEFT_EDGE\
  1948. const int l0= src[-1+0*stride];\
  1949. const int l1= src[-1+1*stride];\
  1950. const int l2= src[-1+2*stride];\
  1951. const int l3= src[-1+3*stride];\
  1952. #define LOAD_TOP_EDGE\
  1953. const int t0= src[ 0-1*stride];\
  1954. const int t1= src[ 1-1*stride];\
  1955. const int t2= src[ 2-1*stride];\
  1956. const int t3= src[ 3-1*stride];\
  1957. static void pred4x4_down_right_c(uint8_t *src, uint8_t *topright, int stride){
  1958. const int lt= src[-1-1*stride];
  1959. LOAD_TOP_EDGE
  1960. LOAD_LEFT_EDGE
  1961. src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2;
  1962. src[0+2*stride]=
  1963. src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2;
  1964. src[0+1*stride]=
  1965. src[1+2*stride]=
  1966. src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2;
  1967. src[0+0*stride]=
  1968. src[1+1*stride]=
  1969. src[2+2*stride]=
  1970. src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2;
  1971. src[1+0*stride]=
  1972. src[2+1*stride]=
  1973. src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2;
  1974. src[2+0*stride]=
  1975. src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;
  1976. src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2;
  1977. }
  1978. static void pred4x4_down_left_c(uint8_t *src, uint8_t *topright, int stride){
  1979. LOAD_TOP_EDGE
  1980. LOAD_TOP_RIGHT_EDGE
  1981. // LOAD_LEFT_EDGE
  1982. src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2;
  1983. src[1+0*stride]=
  1984. src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2;
  1985. src[2+0*stride]=
  1986. src[1+1*stride]=
  1987. src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2;
  1988. src[3+0*stride]=
  1989. src[2+1*stride]=
  1990. src[1+2*stride]=
  1991. src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2;
  1992. src[3+1*stride]=
  1993. src[2+2*stride]=
  1994. src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2;
  1995. src[3+2*stride]=
  1996. src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2;
  1997. src[3+3*stride]=(t6 + 3*t7 + 2)>>2;
  1998. }
  1999. static void pred4x4_vertical_right_c(uint8_t *src, uint8_t *topright, int stride){
  2000. const int lt= src[-1-1*stride];
  2001. LOAD_TOP_EDGE
  2002. LOAD_LEFT_EDGE
  2003. const __attribute__((unused)) int unu= l3;
  2004. src[0+0*stride]=
  2005. src[1+2*stride]=(lt + t0 + 1)>>1;
  2006. src[1+0*stride]=
  2007. src[2+2*stride]=(t0 + t1 + 1)>>1;
  2008. src[2+0*stride]=
  2009. src[3+2*stride]=(t1 + t2 + 1)>>1;
  2010. src[3+0*stride]=(t2 + t3 + 1)>>1;
  2011. src[0+1*stride]=
  2012. src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2;
  2013. src[1+1*stride]=
  2014. src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2;
  2015. src[2+1*stride]=
  2016. src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2;
  2017. src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2;
  2018. src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2;
  2019. src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;
  2020. }
  2021. static void pred4x4_vertical_left_c(uint8_t *src, uint8_t *topright, int stride){
  2022. LOAD_TOP_EDGE
  2023. LOAD_TOP_RIGHT_EDGE
  2024. const __attribute__((unused)) int unu= t7;
  2025. src[0+0*stride]=(t0 + t1 + 1)>>1;
  2026. src[1+0*stride]=
  2027. src[0+2*stride]=(t1 + t2 + 1)>>1;
  2028. src[2+0*stride]=
  2029. src[1+2*stride]=(t2 + t3 + 1)>>1;
  2030. src[3+0*stride]=
  2031. src[2+2*stride]=(t3 + t4+ 1)>>1;
  2032. src[3+2*stride]=(t4 + t5+ 1)>>1;
  2033. src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;
  2034. src[1+1*stride]=
  2035. src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2;
  2036. src[2+1*stride]=
  2037. src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2;
  2038. src[3+1*stride]=
  2039. src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2;
  2040. src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2;
  2041. }
  2042. static void pred4x4_horizontal_up_c(uint8_t *src, uint8_t *topright, int stride){
  2043. LOAD_LEFT_EDGE
  2044. src[0+0*stride]=(l0 + l1 + 1)>>1;
  2045. src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2;
  2046. src[2+0*stride]=
  2047. src[0+1*stride]=(l1 + l2 + 1)>>1;
  2048. src[3+0*stride]=
  2049. src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2;
  2050. src[2+1*stride]=
  2051. src[0+2*stride]=(l2 + l3 + 1)>>1;
  2052. src[3+1*stride]=
  2053. src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2;
  2054. src[3+2*stride]=
  2055. src[1+3*stride]=
  2056. src[0+3*stride]=
  2057. src[2+2*stride]=
  2058. src[2+3*stride]=
  2059. src[3+3*stride]=l3;
  2060. }
  2061. static void pred4x4_horizontal_down_c(uint8_t *src, uint8_t *topright, int stride){
  2062. const int lt= src[-1-1*stride];
  2063. LOAD_TOP_EDGE
  2064. LOAD_LEFT_EDGE
  2065. const __attribute__((unused)) int unu= t3;
  2066. src[0+0*stride]=
  2067. src[2+1*stride]=(lt + l0 + 1)>>1;
  2068. src[1+0*stride]=
  2069. src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2;
  2070. src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2;
  2071. src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2;
  2072. src[0+1*stride]=
  2073. src[2+2*stride]=(l0 + l1 + 1)>>1;
  2074. src[1+1*stride]=
  2075. src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2;
  2076. src[0+2*stride]=
  2077. src[2+3*stride]=(l1 + l2+ 1)>>1;
  2078. src[1+2*stride]=
  2079. src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;
  2080. src[0+3*stride]=(l2 + l3 + 1)>>1;
  2081. src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2;
  2082. }
  2083. static void pred16x16_vertical_c(uint8_t *src, int stride){
  2084. int i;
  2085. const uint32_t a= ((uint32_t*)(src-stride))[0];
  2086. const uint32_t b= ((uint32_t*)(src-stride))[1];
  2087. const uint32_t c= ((uint32_t*)(src-stride))[2];
  2088. const uint32_t d= ((uint32_t*)(src-stride))[3];
  2089. for(i=0; i<16; i++){
  2090. ((uint32_t*)(src+i*stride))[0]= a;
  2091. ((uint32_t*)(src+i*stride))[1]= b;
  2092. ((uint32_t*)(src+i*stride))[2]= c;
  2093. ((uint32_t*)(src+i*stride))[3]= d;
  2094. }
  2095. }
  2096. static void pred16x16_horizontal_c(uint8_t *src, int stride){
  2097. int i;
  2098. for(i=0; i<16; i++){
  2099. ((uint32_t*)(src+i*stride))[0]=
  2100. ((uint32_t*)(src+i*stride))[1]=
  2101. ((uint32_t*)(src+i*stride))[2]=
  2102. ((uint32_t*)(src+i*stride))[3]= src[-1+i*stride]*0x01010101;
  2103. }
  2104. }
  2105. static void pred16x16_dc_c(uint8_t *src, int stride){
  2106. int i, dc=0;
  2107. for(i=0;i<16; i++){
  2108. dc+= src[-1+i*stride];
  2109. }
  2110. for(i=0;i<16; i++){
  2111. dc+= src[i-stride];
  2112. }
  2113. dc= 0x01010101*((dc + 16)>>5);
  2114. for(i=0; i<16; i++){
  2115. ((uint32_t*)(src+i*stride))[0]=
  2116. ((uint32_t*)(src+i*stride))[1]=
  2117. ((uint32_t*)(src+i*stride))[2]=
  2118. ((uint32_t*)(src+i*stride))[3]= dc;
  2119. }
  2120. }
  2121. static void pred16x16_left_dc_c(uint8_t *src, int stride){
  2122. int i, dc=0;
  2123. for(i=0;i<16; i++){
  2124. dc+= src[-1+i*stride];
  2125. }
  2126. dc= 0x01010101*((dc + 8)>>4);
  2127. for(i=0; i<16; i++){
  2128. ((uint32_t*)(src+i*stride))[0]=
  2129. ((uint32_t*)(src+i*stride))[1]=
  2130. ((uint32_t*)(src+i*stride))[2]=
  2131. ((uint32_t*)(src+i*stride))[3]= dc;
  2132. }
  2133. }
  2134. static void pred16x16_top_dc_c(uint8_t *src, int stride){
  2135. int i, dc=0;
  2136. for(i=0;i<16; i++){
  2137. dc+= src[i-stride];
  2138. }
  2139. dc= 0x01010101*((dc + 8)>>4);
  2140. for(i=0; i<16; i++){
  2141. ((uint32_t*)(src+i*stride))[0]=
  2142. ((uint32_t*)(src+i*stride))[1]=
  2143. ((uint32_t*)(src+i*stride))[2]=
  2144. ((uint32_t*)(src+i*stride))[3]= dc;
  2145. }
  2146. }
  2147. static void pred16x16_128_dc_c(uint8_t *src, int stride){
  2148. int i;
  2149. for(i=0; i<16; i++){
  2150. ((uint32_t*)(src+i*stride))[0]=
  2151. ((uint32_t*)(src+i*stride))[1]=
  2152. ((uint32_t*)(src+i*stride))[2]=
  2153. ((uint32_t*)(src+i*stride))[3]= 0x01010101U*128U;
  2154. }
  2155. }
  2156. static inline void pred16x16_plane_compat_c(uint8_t *src, int stride, const int svq3){
  2157. int i, j, k;
  2158. int a;
  2159. uint8_t *cm = cropTbl + MAX_NEG_CROP;
  2160. const uint8_t * const src0 = src+7-stride;
  2161. const uint8_t *src1 = src+8*stride-1;
  2162. const uint8_t *src2 = src1-2*stride; // == src+6*stride-1;
  2163. int H = src0[1] - src0[-1];
  2164. int V = src1[0] - src2[ 0];
  2165. for(k=2; k<=8; ++k) {
  2166. src1 += stride; src2 -= stride;
  2167. H += k*(src0[k] - src0[-k]);
  2168. V += k*(src1[0] - src2[ 0]);
  2169. }
  2170. if(svq3){
  2171. H = ( 5*(H/4) ) / 16;
  2172. V = ( 5*(V/4) ) / 16;
  2173. /* required for 100% accuracy */
  2174. i = H; H = V; V = i;
  2175. }else{
  2176. H = ( 5*H+32 ) >> 6;
  2177. V = ( 5*V+32 ) >> 6;
  2178. }
  2179. a = 16*(src1[0] + src2[16] + 1) - 7*(V+H);
  2180. for(j=16; j>0; --j) {
  2181. int b = a;
  2182. a += V;
  2183. for(i=-16; i<0; i+=4) {
  2184. src[16+i] = cm[ (b ) >> 5 ];
  2185. src[17+i] = cm[ (b+ H) >> 5 ];
  2186. src[18+i] = cm[ (b+2*H) >> 5 ];
  2187. src[19+i] = cm[ (b+3*H) >> 5 ];
  2188. b += 4*H;
  2189. }
  2190. src += stride;
  2191. }
  2192. }
  2193. static void pred16x16_plane_c(uint8_t *src, int stride){
  2194. pred16x16_plane_compat_c(src, stride, 0);
  2195. }
  2196. static void pred8x8_vertical_c(uint8_t *src, int stride){
  2197. int i;
  2198. const uint32_t a= ((uint32_t*)(src-stride))[0];
  2199. const uint32_t b= ((uint32_t*)(src-stride))[1];
  2200. for(i=0; i<8; i++){
  2201. ((uint32_t*)(src+i*stride))[0]= a;
  2202. ((uint32_t*)(src+i*stride))[1]= b;
  2203. }
  2204. }
  2205. static void pred8x8_horizontal_c(uint8_t *src, int stride){
  2206. int i;
  2207. for(i=0; i<8; i++){
  2208. ((uint32_t*)(src+i*stride))[0]=
  2209. ((uint32_t*)(src+i*stride))[1]= src[-1+i*stride]*0x01010101;
  2210. }
  2211. }
  2212. static void pred8x8_128_dc_c(uint8_t *src, int stride){
  2213. int i;
  2214. for(i=0; i<8; i++){
  2215. ((uint32_t*)(src+i*stride))[0]=
  2216. ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U;
  2217. }
  2218. }
  2219. static void pred8x8_left_dc_c(uint8_t *src, int stride){
  2220. int i;
  2221. int dc0, dc2;
  2222. dc0=dc2=0;
  2223. for(i=0;i<4; i++){
  2224. dc0+= src[-1+i*stride];
  2225. dc2+= src[-1+(i+4)*stride];
  2226. }
  2227. dc0= 0x01010101*((dc0 + 2)>>2);
  2228. dc2= 0x01010101*((dc2 + 2)>>2);
  2229. for(i=0; i<4; i++){
  2230. ((uint32_t*)(src+i*stride))[0]=
  2231. ((uint32_t*)(src+i*stride))[1]= dc0;
  2232. }
  2233. for(i=4; i<8; i++){
  2234. ((uint32_t*)(src+i*stride))[0]=
  2235. ((uint32_t*)(src+i*stride))[1]= dc2;
  2236. }
  2237. }
  2238. static void pred8x8_top_dc_c(uint8_t *src, int stride){
  2239. int i;
  2240. int dc0, dc1;
  2241. dc0=dc1=0;
  2242. for(i=0;i<4; i++){
  2243. dc0+= src[i-stride];
  2244. dc1+= src[4+i-stride];
  2245. }
  2246. dc0= 0x01010101*((dc0 + 2)>>2);
  2247. dc1= 0x01010101*((dc1 + 2)>>2);
  2248. for(i=0; i<4; i++){
  2249. ((uint32_t*)(src+i*stride))[0]= dc0;
  2250. ((uint32_t*)(src+i*stride))[1]= dc1;
  2251. }
  2252. for(i=4; i<8; i++){
  2253. ((uint32_t*)(src+i*stride))[0]= dc0;
  2254. ((uint32_t*)(src+i*stride))[1]= dc1;
  2255. }
  2256. }
  2257. static void pred8x8_dc_c(uint8_t *src, int stride){
  2258. int i;
  2259. int dc0, dc1, dc2, dc3;
  2260. dc0=dc1=dc2=0;
  2261. for(i=0;i<4; i++){
  2262. dc0+= src[-1+i*stride] + src[i-stride];
  2263. dc1+= src[4+i-stride];
  2264. dc2+= src[-1+(i+4)*stride];
  2265. }
  2266. dc3= 0x01010101*((dc1 + dc2 + 4)>>3);
  2267. dc0= 0x01010101*((dc0 + 4)>>3);
  2268. dc1= 0x01010101*((dc1 + 2)>>2);
  2269. dc2= 0x01010101*((dc2 + 2)>>2);
  2270. for(i=0; i<4; i++){
  2271. ((uint32_t*)(src+i*stride))[0]= dc0;
  2272. ((uint32_t*)(src+i*stride))[1]= dc1;
  2273. }
  2274. for(i=4; i<8; i++){
  2275. ((uint32_t*)(src+i*stride))[0]= dc2;
  2276. ((uint32_t*)(src+i*stride))[1]= dc3;
  2277. }
  2278. }
  2279. static void pred8x8_plane_c(uint8_t *src, int stride){
  2280. int j, k;
  2281. int a;
  2282. uint8_t *cm = cropTbl + MAX_NEG_CROP;
  2283. const uint8_t * const src0 = src+3-stride;
  2284. const uint8_t *src1 = src+4*stride-1;
  2285. const uint8_t *src2 = src1-2*stride; // == src+2*stride-1;
  2286. int H = src0[1] - src0[-1];
  2287. int V = src1[0] - src2[ 0];
  2288. for(k=2; k<=4; ++k) {
  2289. src1 += stride; src2 -= stride;
  2290. H += k*(src0[k] - src0[-k]);
  2291. V += k*(src1[0] - src2[ 0]);
  2292. }
  2293. H = ( 17*H+16 ) >> 5;
  2294. V = ( 17*V+16 ) >> 5;
  2295. a = 16*(src1[0] + src2[8]+1) - 3*(V+H);
  2296. for(j=8; j>0; --j) {
  2297. int b = a;
  2298. a += V;
  2299. src[0] = cm[ (b ) >> 5 ];
  2300. src[1] = cm[ (b+ H) >> 5 ];
  2301. src[2] = cm[ (b+2*H) >> 5 ];
  2302. src[3] = cm[ (b+3*H) >> 5 ];
  2303. src[4] = cm[ (b+4*H) >> 5 ];
  2304. src[5] = cm[ (b+5*H) >> 5 ];
  2305. src[6] = cm[ (b+6*H) >> 5 ];
  2306. src[7] = cm[ (b+7*H) >> 5 ];
  2307. src += stride;
  2308. }
  2309. }
  2310. #define SRC(x,y) src[(x)+(y)*stride]
  2311. #define PL(y) \
  2312. const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2;
  2313. #define PREDICT_8x8_LOAD_LEFT \
  2314. const int l0 = ((has_topleft ? SRC(-1,-1) : SRC(-1,0)) \
  2315. + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; \
  2316. PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) \
  2317. const int l7 attribute_unused = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2
  2318. #define PT(x) \
  2319. const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
  2320. #define PREDICT_8x8_LOAD_TOP \
  2321. const int t0 = ((has_topleft ? SRC(-1,-1) : SRC(0,-1)) \
  2322. + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; \
  2323. PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) \
  2324. const int t7 attribute_unused = ((has_topright ? SRC(8,-1) : SRC(7,-1)) \
  2325. + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2
  2326. #define PTR(x) \
  2327. t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
  2328. #define PREDICT_8x8_LOAD_TOPRIGHT \
  2329. int t8, t9, t10, t11, t12, t13, t14, t15; \
  2330. if(has_topright) { \
  2331. PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) \
  2332. t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; \
  2333. } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1);
  2334. #define PREDICT_8x8_LOAD_TOPLEFT \
  2335. const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2
  2336. #define PREDICT_8x8_DC(v) \
  2337. int y; \
  2338. for( y = 0; y < 8; y++ ) { \
  2339. ((uint32_t*)src)[0] = \
  2340. ((uint32_t*)src)[1] = v; \
  2341. src += stride; \
  2342. }
  2343. static void pred8x8l_128_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2344. {
  2345. PREDICT_8x8_DC(0x80808080);
  2346. }
  2347. static void pred8x8l_left_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2348. {
  2349. PREDICT_8x8_LOAD_LEFT;
  2350. const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3) * 0x01010101;
  2351. PREDICT_8x8_DC(dc);
  2352. }
  2353. static void pred8x8l_top_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2354. {
  2355. PREDICT_8x8_LOAD_TOP;
  2356. const uint32_t dc = ((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3) * 0x01010101;
  2357. PREDICT_8x8_DC(dc);
  2358. }
  2359. static void pred8x8l_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2360. {
  2361. PREDICT_8x8_LOAD_LEFT;
  2362. PREDICT_8x8_LOAD_TOP;
  2363. const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7
  2364. +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4) * 0x01010101;
  2365. PREDICT_8x8_DC(dc);
  2366. }
  2367. static void pred8x8l_horizontal_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2368. {
  2369. PREDICT_8x8_LOAD_LEFT;
  2370. #define ROW(y) ((uint32_t*)(src+y*stride))[0] =\
  2371. ((uint32_t*)(src+y*stride))[1] = 0x01010101 * l##y
  2372. ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7);
  2373. #undef ROW
  2374. }
  2375. static void pred8x8l_vertical_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2376. {
  2377. int y;
  2378. PREDICT_8x8_LOAD_TOP;
  2379. src[0] = t0;
  2380. src[1] = t1;
  2381. src[2] = t2;
  2382. src[3] = t3;
  2383. src[4] = t4;
  2384. src[5] = t5;
  2385. src[6] = t6;
  2386. src[7] = t7;
  2387. for( y = 1; y < 8; y++ )
  2388. *(uint64_t*)(src+y*stride) = *(uint64_t*)src;
  2389. }
  2390. static void pred8x8l_down_left_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2391. {
  2392. PREDICT_8x8_LOAD_TOP;
  2393. PREDICT_8x8_LOAD_TOPRIGHT;
  2394. SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2;
  2395. SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2;
  2396. SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2;
  2397. SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2;
  2398. SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2;
  2399. SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2;
  2400. 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;
  2401. 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;
  2402. 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;
  2403. SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2;
  2404. SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2;
  2405. SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2;
  2406. SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2;
  2407. SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2;
  2408. SRC(7,7)= (t14 + 3*t15 + 2) >> 2;
  2409. }
  2410. static void pred8x8l_down_right_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2411. {
  2412. PREDICT_8x8_LOAD_TOP;
  2413. PREDICT_8x8_LOAD_LEFT;
  2414. PREDICT_8x8_LOAD_TOPLEFT;
  2415. SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2;
  2416. SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2;
  2417. SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2;
  2418. SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2;
  2419. SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2;
  2420. SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2;
  2421. 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;
  2422. 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;
  2423. 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;
  2424. SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2;
  2425. SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2;
  2426. SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2;
  2427. SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2;
  2428. SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2;
  2429. SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2;
  2430. }
  2431. static void pred8x8l_vertical_right_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2432. {
  2433. PREDICT_8x8_LOAD_TOP;
  2434. PREDICT_8x8_LOAD_LEFT;
  2435. PREDICT_8x8_LOAD_TOPLEFT;
  2436. SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2;
  2437. SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2;
  2438. SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2;
  2439. SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2;
  2440. SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2;
  2441. SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2;
  2442. SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2;
  2443. SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1;
  2444. SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2;
  2445. SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1;
  2446. SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2;
  2447. SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1;
  2448. SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2;
  2449. SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1;
  2450. SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2;
  2451. SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1;
  2452. SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2;
  2453. SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1;
  2454. SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2;
  2455. SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1;
  2456. SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2;
  2457. SRC(7,0)= (t6 + t7 + 1) >> 1;
  2458. }
  2459. static void pred8x8l_horizontal_down_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2460. {
  2461. PREDICT_8x8_LOAD_TOP;
  2462. PREDICT_8x8_LOAD_LEFT;
  2463. PREDICT_8x8_LOAD_TOPLEFT;
  2464. SRC(0,7)= (l6 + l7 + 1) >> 1;
  2465. SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2;
  2466. SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1;
  2467. SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2;
  2468. SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1;
  2469. SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2;
  2470. SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1;
  2471. SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2;
  2472. SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1;
  2473. SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2;
  2474. SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1;
  2475. SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2;
  2476. SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1;
  2477. SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2;
  2478. SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1;
  2479. SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2;
  2480. SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2;
  2481. SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2;
  2482. SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2;
  2483. SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2;
  2484. SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2;
  2485. SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2;
  2486. }
  2487. static void pred8x8l_vertical_left_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2488. {
  2489. PREDICT_8x8_LOAD_TOP;
  2490. PREDICT_8x8_LOAD_TOPRIGHT;
  2491. SRC(0,0)= (t0 + t1 + 1) >> 1;
  2492. SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2;
  2493. SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1;
  2494. SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2;
  2495. SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1;
  2496. SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2;
  2497. SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1;
  2498. SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2;
  2499. SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1;
  2500. SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2;
  2501. SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1;
  2502. SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2;
  2503. SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1;
  2504. SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2;
  2505. SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1;
  2506. SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2;
  2507. SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1;
  2508. SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2;
  2509. SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1;
  2510. SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2;
  2511. SRC(7,6)= (t10 + t11 + 1) >> 1;
  2512. SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2;
  2513. }
  2514. static void pred8x8l_horizontal_up_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2515. {
  2516. PREDICT_8x8_LOAD_LEFT;
  2517. SRC(0,0)= (l0 + l1 + 1) >> 1;
  2518. SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2;
  2519. SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1;
  2520. SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2;
  2521. SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1;
  2522. SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2;
  2523. SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1;
  2524. SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2;
  2525. SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1;
  2526. SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2;
  2527. SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1;
  2528. SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2;
  2529. SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1;
  2530. SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2;
  2531. SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)=
  2532. SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)=
  2533. SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)=
  2534. SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7;
  2535. }
  2536. #undef PREDICT_8x8_LOAD_LEFT
  2537. #undef PREDICT_8x8_LOAD_TOP
  2538. #undef PREDICT_8x8_LOAD_TOPLEFT
  2539. #undef PREDICT_8x8_LOAD_TOPRIGHT
  2540. #undef PREDICT_8x8_DC
  2541. #undef PTR
  2542. #undef PT
  2543. #undef PL
  2544. #undef SRC
  2545. static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,
  2546. uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
  2547. int src_x_offset, int src_y_offset,
  2548. qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){
  2549. MpegEncContext * const s = &h->s;
  2550. const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;
  2551. int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;
  2552. const int luma_xy= (mx&3) + ((my&3)<<2);
  2553. uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize;
  2554. uint8_t * src_cb, * src_cr;
  2555. int extra_width= h->emu_edge_width;
  2556. int extra_height= h->emu_edge_height;
  2557. int emu=0;
  2558. const int full_mx= mx>>2;
  2559. const int full_my= my>>2;
  2560. const int pic_width = 16*s->mb_width;
  2561. const int pic_height = 16*s->mb_height >> MB_MBAFF;
  2562. if(!pic->data[0])
  2563. return;
  2564. if(mx&7) extra_width -= 3;
  2565. if(my&7) extra_height -= 3;
  2566. if( full_mx < 0-extra_width
  2567. || full_my < 0-extra_height
  2568. || full_mx + 16/*FIXME*/ > pic_width + extra_width
  2569. || full_my + 16/*FIXME*/ > pic_height + extra_height){
  2570. 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);
  2571. src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize;
  2572. emu=1;
  2573. }
  2574. qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps?
  2575. if(!square){
  2576. qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize);
  2577. }
  2578. if(s->flags&CODEC_FLAG_GRAY) return;
  2579. if(MB_MBAFF){
  2580. // chroma offset when predicting from a field of opposite parity
  2581. my += 2 * ((s->mb_y & 1) - (h->ref_cache[list][scan8[n]] & 1));
  2582. emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1);
  2583. }
  2584. src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize;
  2585. src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize;
  2586. if(emu){
  2587. 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);
  2588. src_cb= s->edge_emu_buffer;
  2589. }
  2590. chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7);
  2591. if(emu){
  2592. 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);
  2593. src_cr= s->edge_emu_buffer;
  2594. }
  2595. chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7);
  2596. }
  2597. static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta,
  2598. uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
  2599. int x_offset, int y_offset,
  2600. qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
  2601. qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
  2602. int list0, int list1){
  2603. MpegEncContext * const s = &h->s;
  2604. qpel_mc_func *qpix_op= qpix_put;
  2605. h264_chroma_mc_func chroma_op= chroma_put;
  2606. dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize;
  2607. dest_cb += x_offset + y_offset*h->mb_uvlinesize;
  2608. dest_cr += x_offset + y_offset*h->mb_uvlinesize;
  2609. x_offset += 8*s->mb_x;
  2610. y_offset += 8*(s->mb_y >> MB_MBAFF);
  2611. if(list0){
  2612. Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];
  2613. mc_dir_part(h, ref, n, square, chroma_height, delta, 0,
  2614. dest_y, dest_cb, dest_cr, x_offset, y_offset,
  2615. qpix_op, chroma_op);
  2616. qpix_op= qpix_avg;
  2617. chroma_op= chroma_avg;
  2618. }
  2619. if(list1){
  2620. Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];
  2621. mc_dir_part(h, ref, n, square, chroma_height, delta, 1,
  2622. dest_y, dest_cb, dest_cr, x_offset, y_offset,
  2623. qpix_op, chroma_op);
  2624. }
  2625. }
  2626. static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta,
  2627. uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
  2628. int x_offset, int y_offset,
  2629. qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
  2630. h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,
  2631. h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,
  2632. int list0, int list1){
  2633. MpegEncContext * const s = &h->s;
  2634. dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize;
  2635. dest_cb += x_offset + y_offset*h->mb_uvlinesize;
  2636. dest_cr += x_offset + y_offset*h->mb_uvlinesize;
  2637. x_offset += 8*s->mb_x;
  2638. y_offset += 8*(s->mb_y >> MB_MBAFF);
  2639. if(list0 && list1){
  2640. /* don't optimize for luma-only case, since B-frames usually
  2641. * use implicit weights => chroma too. */
  2642. uint8_t *tmp_cb = s->obmc_scratchpad;
  2643. uint8_t *tmp_cr = s->obmc_scratchpad + 8;
  2644. uint8_t *tmp_y = s->obmc_scratchpad + 8*h->mb_uvlinesize;
  2645. int refn0 = h->ref_cache[0][ scan8[n] ];
  2646. int refn1 = h->ref_cache[1][ scan8[n] ];
  2647. mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0,
  2648. dest_y, dest_cb, dest_cr,
  2649. x_offset, y_offset, qpix_put, chroma_put);
  2650. mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1,
  2651. tmp_y, tmp_cb, tmp_cr,
  2652. x_offset, y_offset, qpix_put, chroma_put);
  2653. if(h->use_weight == 2){
  2654. int weight0 = h->implicit_weight[refn0][refn1];
  2655. int weight1 = 64 - weight0;
  2656. luma_weight_avg( dest_y, tmp_y, h-> mb_linesize, 5, weight0, weight1, 0);
  2657. chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0);
  2658. chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0);
  2659. }else{
  2660. luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom,
  2661. h->luma_weight[0][refn0], h->luma_weight[1][refn1],
  2662. h->luma_offset[0][refn0] + h->luma_offset[1][refn1]);
  2663. chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
  2664. h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0],
  2665. h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]);
  2666. chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
  2667. h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1],
  2668. h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]);
  2669. }
  2670. }else{
  2671. int list = list1 ? 1 : 0;
  2672. int refn = h->ref_cache[list][ scan8[n] ];
  2673. Picture *ref= &h->ref_list[list][refn];
  2674. mc_dir_part(h, ref, n, square, chroma_height, delta, list,
  2675. dest_y, dest_cb, dest_cr, x_offset, y_offset,
  2676. qpix_put, chroma_put);
  2677. luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom,
  2678. h->luma_weight[list][refn], h->luma_offset[list][refn]);
  2679. if(h->use_weight_chroma){
  2680. chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
  2681. h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]);
  2682. chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
  2683. h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]);
  2684. }
  2685. }
  2686. }
  2687. static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta,
  2688. uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
  2689. int x_offset, int y_offset,
  2690. qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
  2691. qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
  2692. h264_weight_func *weight_op, h264_biweight_func *weight_avg,
  2693. int list0, int list1){
  2694. if((h->use_weight==2 && list0 && list1
  2695. && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32))
  2696. || h->use_weight==1)
  2697. mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
  2698. x_offset, y_offset, qpix_put, chroma_put,
  2699. weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1);
  2700. else
  2701. mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
  2702. x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1);
  2703. }
  2704. static inline void prefetch_motion(H264Context *h, int list){
  2705. /* fetch pixels for estimated mv 4 macroblocks ahead
  2706. * optimized for 64byte cache lines */
  2707. MpegEncContext * const s = &h->s;
  2708. const int refn = h->ref_cache[list][scan8[0]];
  2709. if(refn >= 0){
  2710. const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8;
  2711. const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y;
  2712. uint8_t **src= h->ref_list[list][refn].data;
  2713. int off= mx + (my + (s->mb_x&3)*4)*h->mb_linesize + 64;
  2714. s->dsp.prefetch(src[0]+off, s->linesize, 4);
  2715. off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
  2716. s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);
  2717. }
  2718. }
  2719. static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
  2720. qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),
  2721. qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),
  2722. h264_weight_func *weight_op, h264_biweight_func *weight_avg){
  2723. MpegEncContext * const s = &h->s;
  2724. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  2725. const int mb_type= s->current_picture.mb_type[mb_xy];
  2726. assert(IS_INTER(mb_type));
  2727. prefetch_motion(h, 0);
  2728. if(IS_16X16(mb_type)){
  2729. mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,
  2730. qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],
  2731. &weight_op[0], &weight_avg[0],
  2732. IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
  2733. }else if(IS_16X8(mb_type)){
  2734. mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0,
  2735. qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
  2736. &weight_op[1], &weight_avg[1],
  2737. IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
  2738. mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4,
  2739. qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
  2740. &weight_op[1], &weight_avg[1],
  2741. IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
  2742. }else if(IS_8X16(mb_type)){
  2743. mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,
  2744. qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
  2745. &weight_op[2], &weight_avg[2],
  2746. IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
  2747. mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,
  2748. qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
  2749. &weight_op[2], &weight_avg[2],
  2750. IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
  2751. }else{
  2752. int i;
  2753. assert(IS_8X8(mb_type));
  2754. for(i=0; i<4; i++){
  2755. const int sub_mb_type= h->sub_mb_type[i];
  2756. const int n= 4*i;
  2757. int x_offset= (i&1)<<2;
  2758. int y_offset= (i&2)<<1;
  2759. if(IS_SUB_8X8(sub_mb_type)){
  2760. mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,
  2761. qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
  2762. &weight_op[3], &weight_avg[3],
  2763. IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
  2764. }else if(IS_SUB_8X4(sub_mb_type)){
  2765. mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset,
  2766. qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
  2767. &weight_op[4], &weight_avg[4],
  2768. IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
  2769. mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,
  2770. qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
  2771. &weight_op[4], &weight_avg[4],
  2772. IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
  2773. }else if(IS_SUB_4X8(sub_mb_type)){
  2774. mc_part(h, n , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,
  2775. qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
  2776. &weight_op[5], &weight_avg[5],
  2777. IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
  2778. mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,
  2779. qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
  2780. &weight_op[5], &weight_avg[5],
  2781. IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
  2782. }else{
  2783. int j;
  2784. assert(IS_SUB_4X4(sub_mb_type));
  2785. for(j=0; j<4; j++){
  2786. int sub_x_offset= x_offset + 2*(j&1);
  2787. int sub_y_offset= y_offset + (j&2);
  2788. mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,
  2789. qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
  2790. &weight_op[6], &weight_avg[6],
  2791. IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
  2792. }
  2793. }
  2794. }
  2795. }
  2796. prefetch_motion(h, 1);
  2797. }
  2798. static void decode_init_vlc(H264Context *h){
  2799. static int done = 0;
  2800. if (!done) {
  2801. int i;
  2802. done = 1;
  2803. init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
  2804. &chroma_dc_coeff_token_len [0], 1, 1,
  2805. &chroma_dc_coeff_token_bits[0], 1, 1, 1);
  2806. for(i=0; i<4; i++){
  2807. init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
  2808. &coeff_token_len [i][0], 1, 1,
  2809. &coeff_token_bits[i][0], 1, 1, 1);
  2810. }
  2811. for(i=0; i<3; i++){
  2812. init_vlc(&chroma_dc_total_zeros_vlc[i], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
  2813. &chroma_dc_total_zeros_len [i][0], 1, 1,
  2814. &chroma_dc_total_zeros_bits[i][0], 1, 1, 1);
  2815. }
  2816. for(i=0; i<15; i++){
  2817. init_vlc(&total_zeros_vlc[i], TOTAL_ZEROS_VLC_BITS, 16,
  2818. &total_zeros_len [i][0], 1, 1,
  2819. &total_zeros_bits[i][0], 1, 1, 1);
  2820. }
  2821. for(i=0; i<6; i++){
  2822. init_vlc(&run_vlc[i], RUN_VLC_BITS, 7,
  2823. &run_len [i][0], 1, 1,
  2824. &run_bits[i][0], 1, 1, 1);
  2825. }
  2826. init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
  2827. &run_len [6][0], 1, 1,
  2828. &run_bits[6][0], 1, 1, 1);
  2829. }
  2830. }
  2831. /**
  2832. * Sets the intra prediction function pointers.
  2833. */
  2834. static void init_pred_ptrs(H264Context *h){
  2835. // MpegEncContext * const s = &h->s;
  2836. h->pred4x4[VERT_PRED ]= pred4x4_vertical_c;
  2837. h->pred4x4[HOR_PRED ]= pred4x4_horizontal_c;
  2838. h->pred4x4[DC_PRED ]= pred4x4_dc_c;
  2839. h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_c;
  2840. h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c;
  2841. h->pred4x4[VERT_RIGHT_PRED ]= pred4x4_vertical_right_c;
  2842. h->pred4x4[HOR_DOWN_PRED ]= pred4x4_horizontal_down_c;
  2843. h->pred4x4[VERT_LEFT_PRED ]= pred4x4_vertical_left_c;
  2844. h->pred4x4[HOR_UP_PRED ]= pred4x4_horizontal_up_c;
  2845. h->pred4x4[LEFT_DC_PRED ]= pred4x4_left_dc_c;
  2846. h->pred4x4[TOP_DC_PRED ]= pred4x4_top_dc_c;
  2847. h->pred4x4[DC_128_PRED ]= pred4x4_128_dc_c;
  2848. h->pred8x8l[VERT_PRED ]= pred8x8l_vertical_c;
  2849. h->pred8x8l[HOR_PRED ]= pred8x8l_horizontal_c;
  2850. h->pred8x8l[DC_PRED ]= pred8x8l_dc_c;
  2851. h->pred8x8l[DIAG_DOWN_LEFT_PRED ]= pred8x8l_down_left_c;
  2852. h->pred8x8l[DIAG_DOWN_RIGHT_PRED]= pred8x8l_down_right_c;
  2853. h->pred8x8l[VERT_RIGHT_PRED ]= pred8x8l_vertical_right_c;
  2854. h->pred8x8l[HOR_DOWN_PRED ]= pred8x8l_horizontal_down_c;
  2855. h->pred8x8l[VERT_LEFT_PRED ]= pred8x8l_vertical_left_c;
  2856. h->pred8x8l[HOR_UP_PRED ]= pred8x8l_horizontal_up_c;
  2857. h->pred8x8l[LEFT_DC_PRED ]= pred8x8l_left_dc_c;
  2858. h->pred8x8l[TOP_DC_PRED ]= pred8x8l_top_dc_c;
  2859. h->pred8x8l[DC_128_PRED ]= pred8x8l_128_dc_c;
  2860. h->pred8x8[DC_PRED8x8 ]= pred8x8_dc_c;
  2861. h->pred8x8[VERT_PRED8x8 ]= pred8x8_vertical_c;
  2862. h->pred8x8[HOR_PRED8x8 ]= pred8x8_horizontal_c;
  2863. h->pred8x8[PLANE_PRED8x8 ]= pred8x8_plane_c;
  2864. h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_c;
  2865. h->pred8x8[TOP_DC_PRED8x8 ]= pred8x8_top_dc_c;
  2866. h->pred8x8[DC_128_PRED8x8 ]= pred8x8_128_dc_c;
  2867. h->pred16x16[DC_PRED8x8 ]= pred16x16_dc_c;
  2868. h->pred16x16[VERT_PRED8x8 ]= pred16x16_vertical_c;
  2869. h->pred16x16[HOR_PRED8x8 ]= pred16x16_horizontal_c;
  2870. h->pred16x16[PLANE_PRED8x8 ]= pred16x16_plane_c;
  2871. h->pred16x16[LEFT_DC_PRED8x8]= pred16x16_left_dc_c;
  2872. h->pred16x16[TOP_DC_PRED8x8 ]= pred16x16_top_dc_c;
  2873. h->pred16x16[DC_128_PRED8x8 ]= pred16x16_128_dc_c;
  2874. }
  2875. static void free_tables(H264Context *h){
  2876. av_freep(&h->intra4x4_pred_mode);
  2877. av_freep(&h->chroma_pred_mode_table);
  2878. av_freep(&h->cbp_table);
  2879. av_freep(&h->mvd_table[0]);
  2880. av_freep(&h->mvd_table[1]);
  2881. av_freep(&h->direct_table);
  2882. av_freep(&h->non_zero_count);
  2883. av_freep(&h->slice_table_base);
  2884. av_freep(&h->top_borders[1]);
  2885. av_freep(&h->top_borders[0]);
  2886. h->slice_table= NULL;
  2887. av_freep(&h->mb2b_xy);
  2888. av_freep(&h->mb2b8_xy);
  2889. av_freep(&h->s.obmc_scratchpad);
  2890. }
  2891. static void init_dequant8_coeff_table(H264Context *h){
  2892. int i,q,x;
  2893. const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly
  2894. h->dequant8_coeff[0] = h->dequant8_buffer[0];
  2895. h->dequant8_coeff[1] = h->dequant8_buffer[1];
  2896. for(i=0; i<2; i++ ){
  2897. if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){
  2898. h->dequant8_coeff[1] = h->dequant8_buffer[0];
  2899. break;
  2900. }
  2901. for(q=0; q<52; q++){
  2902. int shift = div6[q];
  2903. int idx = rem6[q];
  2904. for(x=0; x<64; x++)
  2905. h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] =
  2906. ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] *
  2907. h->pps.scaling_matrix8[i][x]) << shift;
  2908. }
  2909. }
  2910. }
  2911. static void init_dequant4_coeff_table(H264Context *h){
  2912. int i,j,q,x;
  2913. const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly
  2914. for(i=0; i<6; i++ ){
  2915. h->dequant4_coeff[i] = h->dequant4_buffer[i];
  2916. for(j=0; j<i; j++){
  2917. if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){
  2918. h->dequant4_coeff[i] = h->dequant4_buffer[j];
  2919. break;
  2920. }
  2921. }
  2922. if(j<i)
  2923. continue;
  2924. for(q=0; q<52; q++){
  2925. int shift = div6[q] + 2;
  2926. int idx = rem6[q];
  2927. for(x=0; x<16; x++)
  2928. h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] =
  2929. ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] *
  2930. h->pps.scaling_matrix4[i][x]) << shift;
  2931. }
  2932. }
  2933. }
  2934. static void init_dequant_tables(H264Context *h){
  2935. int i,x;
  2936. init_dequant4_coeff_table(h);
  2937. if(h->pps.transform_8x8_mode)
  2938. init_dequant8_coeff_table(h);
  2939. if(h->sps.transform_bypass){
  2940. for(i=0; i<6; i++)
  2941. for(x=0; x<16; x++)
  2942. h->dequant4_coeff[i][0][x] = 1<<6;
  2943. if(h->pps.transform_8x8_mode)
  2944. for(i=0; i<2; i++)
  2945. for(x=0; x<64; x++)
  2946. h->dequant8_coeff[i][0][x] = 1<<6;
  2947. }
  2948. }
  2949. /**
  2950. * allocates tables.
  2951. * needs width/height
  2952. */
  2953. static int alloc_tables(H264Context *h){
  2954. MpegEncContext * const s = &h->s;
  2955. const int big_mb_num= s->mb_stride * (s->mb_height+1);
  2956. int x,y;
  2957. CHECKED_ALLOCZ(h->intra4x4_pred_mode, big_mb_num * 8 * sizeof(uint8_t))
  2958. CHECKED_ALLOCZ(h->non_zero_count , big_mb_num * 16 * sizeof(uint8_t))
  2959. CHECKED_ALLOCZ(h->slice_table_base , (big_mb_num+s->mb_stride) * sizeof(uint8_t))
  2960. CHECKED_ALLOCZ(h->top_borders[0] , s->mb_width * (16+8+8) * sizeof(uint8_t))
  2961. CHECKED_ALLOCZ(h->top_borders[1] , s->mb_width * (16+8+8) * sizeof(uint8_t))
  2962. CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t))
  2963. if( h->pps.cabac ) {
  2964. CHECKED_ALLOCZ(h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t))
  2965. CHECKED_ALLOCZ(h->mvd_table[0], 32*big_mb_num * sizeof(uint16_t));
  2966. CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t));
  2967. CHECKED_ALLOCZ(h->direct_table, 32*big_mb_num * sizeof(uint8_t));
  2968. }
  2969. memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride) * sizeof(uint8_t));
  2970. h->slice_table= h->slice_table_base + s->mb_stride*2 + 1;
  2971. CHECKED_ALLOCZ(h->mb2b_xy , big_mb_num * sizeof(uint32_t));
  2972. CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t));
  2973. for(y=0; y<s->mb_height; y++){
  2974. for(x=0; x<s->mb_width; x++){
  2975. const int mb_xy= x + y*s->mb_stride;
  2976. const int b_xy = 4*x + 4*y*h->b_stride;
  2977. const int b8_xy= 2*x + 2*y*h->b8_stride;
  2978. h->mb2b_xy [mb_xy]= b_xy;
  2979. h->mb2b8_xy[mb_xy]= b8_xy;
  2980. }
  2981. }
  2982. s->obmc_scratchpad = NULL;
  2983. if(!h->dequant4_coeff[0])
  2984. init_dequant_tables(h);
  2985. return 0;
  2986. fail:
  2987. free_tables(h);
  2988. return -1;
  2989. }
  2990. static void common_init(H264Context *h){
  2991. MpegEncContext * const s = &h->s;
  2992. s->width = s->avctx->width;
  2993. s->height = s->avctx->height;
  2994. s->codec_id= s->avctx->codec->id;
  2995. init_pred_ptrs(h);
  2996. h->dequant_coeff_pps= -1;
  2997. s->unrestricted_mv=1;
  2998. s->decode=1; //FIXME
  2999. memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));
  3000. memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));
  3001. }
  3002. static int decode_init(AVCodecContext *avctx){
  3003. H264Context *h= avctx->priv_data;
  3004. MpegEncContext * const s = &h->s;
  3005. MPV_decode_defaults(s);
  3006. s->avctx = avctx;
  3007. common_init(h);
  3008. s->out_format = FMT_H264;
  3009. s->workaround_bugs= avctx->workaround_bugs;
  3010. // set defaults
  3011. // s->decode_mb= ff_h263_decode_mb;
  3012. s->low_delay= 1;
  3013. avctx->pix_fmt= PIX_FMT_YUV420P;
  3014. decode_init_vlc(h);
  3015. if(avctx->extradata_size > 0 && avctx->extradata &&
  3016. *(char *)avctx->extradata == 1){
  3017. h->is_avc = 1;
  3018. h->got_avcC = 0;
  3019. } else {
  3020. h->is_avc = 0;
  3021. }
  3022. return 0;
  3023. }
  3024. static int frame_start(H264Context *h){
  3025. MpegEncContext * const s = &h->s;
  3026. int i;
  3027. if(MPV_frame_start(s, s->avctx) < 0)
  3028. return -1;
  3029. ff_er_frame_start(s);
  3030. assert(s->linesize && s->uvlinesize);
  3031. for(i=0; i<16; i++){
  3032. h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3);
  3033. h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3);
  3034. }
  3035. for(i=0; i<4; i++){
  3036. h->block_offset[16+i]=
  3037. h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);
  3038. h->block_offset[24+16+i]=
  3039. h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3);
  3040. }
  3041. /* can't be in alloc_tables because linesize isn't known there.
  3042. * FIXME: redo bipred weight to not require extra buffer? */
  3043. if(!s->obmc_scratchpad)
  3044. s->obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);
  3045. /* some macroblocks will be accessed before they're available */
  3046. if(FRAME_MBAFF)
  3047. memset(h->slice_table, -1, (s->mb_height*s->mb_stride-1) * sizeof(uint8_t));
  3048. // s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;
  3049. return 0;
  3050. }
  3051. static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){
  3052. MpegEncContext * const s = &h->s;
  3053. int i;
  3054. src_y -= linesize;
  3055. src_cb -= uvlinesize;
  3056. src_cr -= uvlinesize;
  3057. // There are two lines saved, the line above the the top macroblock of a pair,
  3058. // and the line above the bottom macroblock
  3059. h->left_border[0]= h->top_borders[0][s->mb_x][15];
  3060. for(i=1; i<17; i++){
  3061. h->left_border[i]= src_y[15+i* linesize];
  3062. }
  3063. *(uint64_t*)(h->top_borders[0][s->mb_x]+0)= *(uint64_t*)(src_y + 16*linesize);
  3064. *(uint64_t*)(h->top_borders[0][s->mb_x]+8)= *(uint64_t*)(src_y +8+16*linesize);
  3065. if(!(s->flags&CODEC_FLAG_GRAY)){
  3066. h->left_border[17 ]= h->top_borders[0][s->mb_x][16+7];
  3067. h->left_border[17+9]= h->top_borders[0][s->mb_x][24+7];
  3068. for(i=1; i<9; i++){
  3069. h->left_border[i+17 ]= src_cb[7+i*uvlinesize];
  3070. h->left_border[i+17+9]= src_cr[7+i*uvlinesize];
  3071. }
  3072. *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+8*uvlinesize);
  3073. *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+8*uvlinesize);
  3074. }
  3075. }
  3076. 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){
  3077. MpegEncContext * const s = &h->s;
  3078. int temp8, i;
  3079. uint64_t temp64;
  3080. int deblock_left = (s->mb_x > 0);
  3081. int deblock_top = (s->mb_y > 0);
  3082. src_y -= linesize + 1;
  3083. src_cb -= uvlinesize + 1;
  3084. src_cr -= uvlinesize + 1;
  3085. #define XCHG(a,b,t,xchg)\
  3086. t= a;\
  3087. if(xchg)\
  3088. a= b;\
  3089. b= t;
  3090. if(deblock_left){
  3091. for(i = !deblock_top; i<17; i++){
  3092. XCHG(h->left_border[i ], src_y [i* linesize], temp8, xchg);
  3093. }
  3094. }
  3095. if(deblock_top){
  3096. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg);
  3097. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1);
  3098. if(s->mb_x+1 < s->mb_width){
  3099. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1);
  3100. }
  3101. }
  3102. if(!(s->flags&CODEC_FLAG_GRAY)){
  3103. if(deblock_left){
  3104. for(i = !deblock_top; i<9; i++){
  3105. XCHG(h->left_border[i+17 ], src_cb[i*uvlinesize], temp8, xchg);
  3106. XCHG(h->left_border[i+17+9], src_cr[i*uvlinesize], temp8, xchg);
  3107. }
  3108. }
  3109. if(deblock_top){
  3110. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1);
  3111. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1);
  3112. }
  3113. }
  3114. }
  3115. static inline void backup_pair_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){
  3116. MpegEncContext * const s = &h->s;
  3117. int i;
  3118. src_y -= 2 * linesize;
  3119. src_cb -= 2 * uvlinesize;
  3120. src_cr -= 2 * uvlinesize;
  3121. // There are two lines saved, the line above the the top macroblock of a pair,
  3122. // and the line above the bottom macroblock
  3123. h->left_border[0]= h->top_borders[0][s->mb_x][15];
  3124. h->left_border[1]= h->top_borders[1][s->mb_x][15];
  3125. for(i=2; i<34; i++){
  3126. h->left_border[i]= src_y[15+i* linesize];
  3127. }
  3128. *(uint64_t*)(h->top_borders[0][s->mb_x]+0)= *(uint64_t*)(src_y + 32*linesize);
  3129. *(uint64_t*)(h->top_borders[0][s->mb_x]+8)= *(uint64_t*)(src_y +8+32*linesize);
  3130. *(uint64_t*)(h->top_borders[1][s->mb_x]+0)= *(uint64_t*)(src_y + 33*linesize);
  3131. *(uint64_t*)(h->top_borders[1][s->mb_x]+8)= *(uint64_t*)(src_y +8+33*linesize);
  3132. if(!(s->flags&CODEC_FLAG_GRAY)){
  3133. h->left_border[34 ]= h->top_borders[0][s->mb_x][16+7];
  3134. h->left_border[34+ 1]= h->top_borders[1][s->mb_x][16+7];
  3135. h->left_border[34+18 ]= h->top_borders[0][s->mb_x][24+7];
  3136. h->left_border[34+18+1]= h->top_borders[1][s->mb_x][24+7];
  3137. for(i=2; i<18; i++){
  3138. h->left_border[i+34 ]= src_cb[7+i*uvlinesize];
  3139. h->left_border[i+34+18]= src_cr[7+i*uvlinesize];
  3140. }
  3141. *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+16*uvlinesize);
  3142. *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+16*uvlinesize);
  3143. *(uint64_t*)(h->top_borders[1][s->mb_x]+16)= *(uint64_t*)(src_cb+17*uvlinesize);
  3144. *(uint64_t*)(h->top_borders[1][s->mb_x]+24)= *(uint64_t*)(src_cr+17*uvlinesize);
  3145. }
  3146. }
  3147. 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){
  3148. MpegEncContext * const s = &h->s;
  3149. int temp8, i;
  3150. uint64_t temp64;
  3151. int deblock_left = (s->mb_x > 0);
  3152. int deblock_top = (s->mb_y > 1);
  3153. 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);
  3154. src_y -= 2 * linesize + 1;
  3155. src_cb -= 2 * uvlinesize + 1;
  3156. src_cr -= 2 * uvlinesize + 1;
  3157. #define XCHG(a,b,t,xchg)\
  3158. t= a;\
  3159. if(xchg)\
  3160. a= b;\
  3161. b= t;
  3162. if(deblock_left){
  3163. for(i = (!deblock_top)<<1; i<34; i++){
  3164. XCHG(h->left_border[i ], src_y [i* linesize], temp8, xchg);
  3165. }
  3166. }
  3167. if(deblock_top){
  3168. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg);
  3169. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1);
  3170. XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+0), *(uint64_t*)(src_y +1 +linesize), temp64, xchg);
  3171. XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+8), *(uint64_t*)(src_y +9 +linesize), temp64, 1);
  3172. if(s->mb_x+1 < s->mb_width){
  3173. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1);
  3174. XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x+1]), *(uint64_t*)(src_y +17 +linesize), temp64, 1);
  3175. }
  3176. }
  3177. if(!(s->flags&CODEC_FLAG_GRAY)){
  3178. if(deblock_left){
  3179. for(i = (!deblock_top) << 1; i<18; i++){
  3180. XCHG(h->left_border[i+34 ], src_cb[i*uvlinesize], temp8, xchg);
  3181. XCHG(h->left_border[i+34+18], src_cr[i*uvlinesize], temp8, xchg);
  3182. }
  3183. }
  3184. if(deblock_top){
  3185. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1);
  3186. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1);
  3187. XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+16), *(uint64_t*)(src_cb+1 +uvlinesize), temp64, 1);
  3188. XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+24), *(uint64_t*)(src_cr+1 +uvlinesize), temp64, 1);
  3189. }
  3190. }
  3191. }
  3192. static void hl_decode_mb(H264Context *h){
  3193. MpegEncContext * const s = &h->s;
  3194. const int mb_x= s->mb_x;
  3195. const int mb_y= s->mb_y;
  3196. const int mb_xy= mb_x + mb_y*s->mb_stride;
  3197. const int mb_type= s->current_picture.mb_type[mb_xy];
  3198. uint8_t *dest_y, *dest_cb, *dest_cr;
  3199. int linesize, uvlinesize /*dct_offset*/;
  3200. int i;
  3201. int *block_offset = &h->block_offset[0];
  3202. const unsigned int bottom = mb_y & 1;
  3203. const int transform_bypass = (s->qscale == 0 && h->sps.transform_bypass);
  3204. void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
  3205. void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
  3206. if(!s->decode)
  3207. return;
  3208. dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16;
  3209. dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
  3210. dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
  3211. if (MB_FIELD) {
  3212. linesize = h->mb_linesize = s->linesize * 2;
  3213. uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
  3214. block_offset = &h->block_offset[24];
  3215. if(mb_y&1){ //FIXME move out of this func?
  3216. dest_y -= s->linesize*15;
  3217. dest_cb-= s->uvlinesize*7;
  3218. dest_cr-= s->uvlinesize*7;
  3219. }
  3220. if(FRAME_MBAFF) {
  3221. int list;
  3222. for(list=0; list<2; list++){
  3223. if(!USES_LIST(mb_type, list))
  3224. continue;
  3225. if(IS_16X16(mb_type)){
  3226. int8_t *ref = &h->ref_cache[list][scan8[0]];
  3227. fill_rectangle(ref, 4, 4, 8, 16+*ref^(s->mb_y&1), 1);
  3228. }else{
  3229. for(i=0; i<16; i+=4){
  3230. //FIXME can refs be smaller than 8x8 when !direct_8x8_inference ?
  3231. int ref = h->ref_cache[list][scan8[i]];
  3232. if(ref >= 0)
  3233. fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, 16+ref^(s->mb_y&1), 1);
  3234. }
  3235. }
  3236. }
  3237. }
  3238. } else {
  3239. linesize = h->mb_linesize = s->linesize;
  3240. uvlinesize = h->mb_uvlinesize = s->uvlinesize;
  3241. // dct_offset = s->linesize * 16;
  3242. }
  3243. if(transform_bypass){
  3244. idct_dc_add =
  3245. idct_add = IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4;
  3246. }else if(IS_8x8DCT(mb_type)){
  3247. idct_dc_add = s->dsp.h264_idct8_dc_add;
  3248. idct_add = s->dsp.h264_idct8_add;
  3249. }else{
  3250. idct_dc_add = s->dsp.h264_idct_dc_add;
  3251. idct_add = s->dsp.h264_idct_add;
  3252. }
  3253. if(FRAME_MBAFF && h->deblocking_filter && IS_INTRA(mb_type)
  3254. && (!bottom || !IS_INTRA(s->current_picture.mb_type[mb_xy-s->mb_stride]))){
  3255. int mbt_y = mb_y&~1;
  3256. uint8_t *top_y = s->current_picture.data[0] + (mbt_y * 16* s->linesize ) + mb_x * 16;
  3257. uint8_t *top_cb = s->current_picture.data[1] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8;
  3258. uint8_t *top_cr = s->current_picture.data[2] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8;
  3259. xchg_pair_border(h, top_y, top_cb, top_cr, s->linesize, s->uvlinesize, 1);
  3260. }
  3261. if (IS_INTRA_PCM(mb_type)) {
  3262. unsigned int x, y;
  3263. // The pixels are stored in h->mb array in the same order as levels,
  3264. // copy them in output in the correct order.
  3265. for(i=0; i<16; i++) {
  3266. for (y=0; y<4; y++) {
  3267. for (x=0; x<4; x++) {
  3268. *(dest_y + block_offset[i] + y*linesize + x) = h->mb[i*16+y*4+x];
  3269. }
  3270. }
  3271. }
  3272. for(i=16; i<16+4; i++) {
  3273. for (y=0; y<4; y++) {
  3274. for (x=0; x<4; x++) {
  3275. *(dest_cb + block_offset[i] + y*uvlinesize + x) = h->mb[i*16+y*4+x];
  3276. }
  3277. }
  3278. }
  3279. for(i=20; i<20+4; i++) {
  3280. for (y=0; y<4; y++) {
  3281. for (x=0; x<4; x++) {
  3282. *(dest_cr + block_offset[i] + y*uvlinesize + x) = h->mb[i*16+y*4+x];
  3283. }
  3284. }
  3285. }
  3286. } else {
  3287. if(IS_INTRA(mb_type)){
  3288. if(h->deblocking_filter && !FRAME_MBAFF)
  3289. xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1);
  3290. if(!(s->flags&CODEC_FLAG_GRAY)){
  3291. h->pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);
  3292. h->pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);
  3293. }
  3294. if(IS_INTRA4x4(mb_type)){
  3295. if(!s->encoding){
  3296. if(IS_8x8DCT(mb_type)){
  3297. for(i=0; i<16; i+=4){
  3298. uint8_t * const ptr= dest_y + block_offset[i];
  3299. const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
  3300. const int nnz = h->non_zero_count_cache[ scan8[i] ];
  3301. h->pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,
  3302. (h->topright_samples_available<<(i+1))&0x8000, linesize);
  3303. if(nnz){
  3304. if(nnz == 1 && h->mb[i*16])
  3305. idct_dc_add(ptr, h->mb + i*16, linesize);
  3306. else
  3307. idct_add(ptr, h->mb + i*16, linesize);
  3308. }
  3309. }
  3310. }else
  3311. for(i=0; i<16; i++){
  3312. uint8_t * const ptr= dest_y + block_offset[i];
  3313. uint8_t *topright;
  3314. const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
  3315. int nnz, tr;
  3316. if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){
  3317. const int topright_avail= (h->topright_samples_available<<i)&0x8000;
  3318. assert(mb_y || linesize <= block_offset[i]);
  3319. if(!topright_avail){
  3320. tr= ptr[3 - linesize]*0x01010101;
  3321. topright= (uint8_t*) &tr;
  3322. }else
  3323. topright= ptr + 4 - linesize;
  3324. }else
  3325. topright= NULL;
  3326. h->pred4x4[ dir ](ptr, topright, linesize);
  3327. nnz = h->non_zero_count_cache[ scan8[i] ];
  3328. if(nnz){
  3329. if(s->codec_id == CODEC_ID_H264){
  3330. if(nnz == 1 && h->mb[i*16])
  3331. idct_dc_add(ptr, h->mb + i*16, linesize);
  3332. else
  3333. idct_add(ptr, h->mb + i*16, linesize);
  3334. }else
  3335. svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);
  3336. }
  3337. }
  3338. }
  3339. }else{
  3340. h->pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);
  3341. if(s->codec_id == CODEC_ID_H264){
  3342. if(!transform_bypass)
  3343. h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[IS_INTRA(mb_type) ? 0:3][s->qscale][0]);
  3344. }else
  3345. svq3_luma_dc_dequant_idct_c(h->mb, s->qscale);
  3346. }
  3347. if(h->deblocking_filter && !FRAME_MBAFF)
  3348. xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0);
  3349. }else if(s->codec_id == CODEC_ID_H264){
  3350. hl_motion(h, dest_y, dest_cb, dest_cr,
  3351. s->dsp.put_h264_qpel_pixels_tab, s->dsp.put_h264_chroma_pixels_tab,
  3352. s->dsp.avg_h264_qpel_pixels_tab, s->dsp.avg_h264_chroma_pixels_tab,
  3353. s->dsp.weight_h264_pixels_tab, s->dsp.biweight_h264_pixels_tab);
  3354. }
  3355. if(!IS_INTRA4x4(mb_type)){
  3356. if(s->codec_id == CODEC_ID_H264){
  3357. if(IS_INTRA16x16(mb_type)){
  3358. for(i=0; i<16; i++){
  3359. if(h->non_zero_count_cache[ scan8[i] ])
  3360. idct_add(dest_y + block_offset[i], h->mb + i*16, linesize);
  3361. else if(h->mb[i*16])
  3362. idct_dc_add(dest_y + block_offset[i], h->mb + i*16, linesize);
  3363. }
  3364. }else{
  3365. const int di = IS_8x8DCT(mb_type) ? 4 : 1;
  3366. for(i=0; i<16; i+=di){
  3367. int nnz = h->non_zero_count_cache[ scan8[i] ];
  3368. if(nnz){
  3369. if(nnz==1 && h->mb[i*16])
  3370. idct_dc_add(dest_y + block_offset[i], h->mb + i*16, linesize);
  3371. else
  3372. idct_add(dest_y + block_offset[i], h->mb + i*16, linesize);
  3373. }
  3374. }
  3375. }
  3376. }else{
  3377. for(i=0; i<16; i++){
  3378. if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below
  3379. uint8_t * const ptr= dest_y + block_offset[i];
  3380. svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0);
  3381. }
  3382. }
  3383. }
  3384. }
  3385. if(!(s->flags&CODEC_FLAG_GRAY)){
  3386. uint8_t *dest[2] = {dest_cb, dest_cr};
  3387. if(transform_bypass){
  3388. idct_add = idct_dc_add = s->dsp.add_pixels4;
  3389. }else{
  3390. idct_add = s->dsp.h264_idct_add;
  3391. idct_dc_add = s->dsp.h264_idct_dc_add;
  3392. 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]);
  3393. 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]);
  3394. }
  3395. if(s->codec_id == CODEC_ID_H264){
  3396. for(i=16; i<16+8; i++){
  3397. if(h->non_zero_count_cache[ scan8[i] ])
  3398. idct_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
  3399. else if(h->mb[i*16])
  3400. idct_dc_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
  3401. }
  3402. }else{
  3403. for(i=16; i<16+8; i++){
  3404. if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
  3405. uint8_t * const ptr= dest[(i&4)>>2] + block_offset[i];
  3406. svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2);
  3407. }
  3408. }
  3409. }
  3410. }
  3411. }
  3412. if(h->deblocking_filter) {
  3413. if (FRAME_MBAFF) {
  3414. //FIXME try deblocking one mb at a time?
  3415. // the reduction in load/storing mvs and such might outweigh the extra backup/xchg_border
  3416. const int mb_y = s->mb_y - 1;
  3417. uint8_t *pair_dest_y, *pair_dest_cb, *pair_dest_cr;
  3418. const int mb_xy= mb_x + mb_y*s->mb_stride;
  3419. const int mb_type_top = s->current_picture.mb_type[mb_xy];
  3420. const int mb_type_bottom= s->current_picture.mb_type[mb_xy+s->mb_stride];
  3421. if (!bottom) return;
  3422. pair_dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16;
  3423. pair_dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
  3424. pair_dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
  3425. if(IS_INTRA(mb_type_top | mb_type_bottom))
  3426. xchg_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize, 0);
  3427. backup_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize);
  3428. // deblock a pair
  3429. // top
  3430. s->mb_y--;
  3431. 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);
  3432. fill_caches(h, mb_type_top, 1); //FIXME don't fill stuff which isn't used by filter_mb
  3433. h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mb_xy]);
  3434. filter_mb(h, mb_x, mb_y, pair_dest_y, pair_dest_cb, pair_dest_cr, linesize, uvlinesize);
  3435. // bottom
  3436. s->mb_y++;
  3437. tprintf("call mbaff filter_mb\n");
  3438. fill_caches(h, mb_type_bottom, 1); //FIXME don't fill stuff which isn't used by filter_mb
  3439. h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mb_xy+s->mb_stride]);
  3440. filter_mb(h, mb_x, mb_y+1, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
  3441. } else {
  3442. tprintf("call filter_mb\n");
  3443. backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
  3444. fill_caches(h, mb_type, 1); //FIXME don't fill stuff which isn't used by filter_mb
  3445. filter_mb(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
  3446. }
  3447. }
  3448. }
  3449. /**
  3450. * fills the default_ref_list.
  3451. */
  3452. static int fill_default_ref_list(H264Context *h){
  3453. MpegEncContext * const s = &h->s;
  3454. int i;
  3455. int smallest_poc_greater_than_current = -1;
  3456. Picture sorted_short_ref[32];
  3457. if(h->slice_type==B_TYPE){
  3458. int out_i;
  3459. int limit= INT_MIN;
  3460. /* sort frame according to poc in B slice */
  3461. for(out_i=0; out_i<h->short_ref_count; out_i++){
  3462. int best_i=INT_MIN;
  3463. int best_poc=INT_MAX;
  3464. for(i=0; i<h->short_ref_count; i++){
  3465. const int poc= h->short_ref[i]->poc;
  3466. if(poc > limit && poc < best_poc){
  3467. best_poc= poc;
  3468. best_i= i;
  3469. }
  3470. }
  3471. assert(best_i != INT_MIN);
  3472. limit= best_poc;
  3473. sorted_short_ref[out_i]= *h->short_ref[best_i];
  3474. 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);
  3475. if (-1 == smallest_poc_greater_than_current) {
  3476. if (h->short_ref[best_i]->poc >= s->current_picture_ptr->poc) {
  3477. smallest_poc_greater_than_current = out_i;
  3478. }
  3479. }
  3480. }
  3481. }
  3482. if(s->picture_structure == PICT_FRAME){
  3483. if(h->slice_type==B_TYPE){
  3484. int list;
  3485. tprintf("current poc: %d, smallest_poc_greater_than_current: %d\n", s->current_picture_ptr->poc, smallest_poc_greater_than_current);
  3486. // find the largest poc
  3487. for(list=0; list<2; list++){
  3488. int index = 0;
  3489. int j= -99;
  3490. int step= list ? -1 : 1;
  3491. for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++, j+=step) {
  3492. while(j<0 || j>= h->short_ref_count){
  3493. if(j != -99 && step == (list ? -1 : 1))
  3494. return -1;
  3495. step = -step;
  3496. j= smallest_poc_greater_than_current + (step>>1);
  3497. }
  3498. if(sorted_short_ref[j].reference != 3) continue;
  3499. h->default_ref_list[list][index ]= sorted_short_ref[j];
  3500. h->default_ref_list[list][index++].pic_id= sorted_short_ref[j].frame_num;
  3501. }
  3502. for(i = 0; i < 16 && index < h->ref_count[ list ]; i++){
  3503. if(h->long_ref[i] == NULL) continue;
  3504. if(h->long_ref[i]->reference != 3) continue;
  3505. h->default_ref_list[ list ][index ]= *h->long_ref[i];
  3506. h->default_ref_list[ list ][index++].pic_id= i;;
  3507. }
  3508. if(list && (smallest_poc_greater_than_current<=0 || smallest_poc_greater_than_current>=h->short_ref_count) && (1 < index)){
  3509. // swap the two first elements of L1 when
  3510. // L0 and L1 are identical
  3511. Picture temp= h->default_ref_list[1][0];
  3512. h->default_ref_list[1][0] = h->default_ref_list[1][1];
  3513. h->default_ref_list[1][1] = temp;
  3514. }
  3515. if(index < h->ref_count[ list ])
  3516. memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index));
  3517. }
  3518. }else{
  3519. int index=0;
  3520. for(i=0; i<h->short_ref_count; i++){
  3521. if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit
  3522. h->default_ref_list[0][index ]= *h->short_ref[i];
  3523. h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num;
  3524. }
  3525. for(i = 0; i < 16; i++){
  3526. if(h->long_ref[i] == NULL) continue;
  3527. if(h->long_ref[i]->reference != 3) continue;
  3528. h->default_ref_list[0][index ]= *h->long_ref[i];
  3529. h->default_ref_list[0][index++].pic_id= i;;
  3530. }
  3531. if(index < h->ref_count[0])
  3532. memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index));
  3533. }
  3534. }else{ //FIELD
  3535. if(h->slice_type==B_TYPE){
  3536. }else{
  3537. //FIXME second field balh
  3538. }
  3539. }
  3540. #ifdef TRACE
  3541. for (i=0; i<h->ref_count[0]; i++) {
  3542. 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]);
  3543. }
  3544. if(h->slice_type==B_TYPE){
  3545. for (i=0; i<h->ref_count[1]; i++) {
  3546. 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]);
  3547. }
  3548. }
  3549. #endif
  3550. return 0;
  3551. }
  3552. static void print_short_term(H264Context *h);
  3553. static void print_long_term(H264Context *h);
  3554. static int decode_ref_pic_list_reordering(H264Context *h){
  3555. MpegEncContext * const s = &h->s;
  3556. int list, index;
  3557. print_short_term(h);
  3558. print_long_term(h);
  3559. if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move before func
  3560. for(list=0; list<2; list++){
  3561. memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]);
  3562. if(get_bits1(&s->gb)){
  3563. int pred= h->curr_pic_num;
  3564. for(index=0; ; index++){
  3565. int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb);
  3566. int pic_id;
  3567. int i;
  3568. Picture *ref = NULL;
  3569. if(reordering_of_pic_nums_idc==3)
  3570. break;
  3571. if(index >= h->ref_count[list]){
  3572. av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n");
  3573. return -1;
  3574. }
  3575. if(reordering_of_pic_nums_idc<3){
  3576. if(reordering_of_pic_nums_idc<2){
  3577. const int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1;
  3578. if(abs_diff_pic_num >= h->max_pic_num){
  3579. av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n");
  3580. return -1;
  3581. }
  3582. if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num;
  3583. else pred+= abs_diff_pic_num;
  3584. pred &= h->max_pic_num - 1;
  3585. for(i= h->short_ref_count-1; i>=0; i--){
  3586. ref = h->short_ref[i];
  3587. assert(ref->reference == 3);
  3588. assert(!ref->long_ref);
  3589. if(ref->data[0] != NULL && ref->frame_num == pred && ref->long_ref == 0) // ignore non existing pictures by testing data[0] pointer
  3590. break;
  3591. }
  3592. if(i>=0)
  3593. ref->pic_id= ref->frame_num;
  3594. }else{
  3595. pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx
  3596. ref = h->long_ref[pic_id];
  3597. ref->pic_id= pic_id;
  3598. assert(ref->reference == 3);
  3599. assert(ref->long_ref);
  3600. i=0;
  3601. }
  3602. if (i < 0) {
  3603. av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n");
  3604. memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME
  3605. } else {
  3606. for(i=index; i+1<h->ref_count[list]; i++){
  3607. if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id)
  3608. break;
  3609. }
  3610. for(; i > index; i--){
  3611. h->ref_list[list][i]= h->ref_list[list][i-1];
  3612. }
  3613. h->ref_list[list][index]= *ref;
  3614. }
  3615. }else{
  3616. av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n");
  3617. return -1;
  3618. }
  3619. }
  3620. }
  3621. if(h->slice_type!=B_TYPE) break;
  3622. }
  3623. for(list=0; list<2; list++){
  3624. for(index= 0; index < h->ref_count[list]; index++){
  3625. if(!h->ref_list[list][index].data[0])
  3626. h->ref_list[list][index]= s->current_picture;
  3627. }
  3628. if(h->slice_type!=B_TYPE) break;
  3629. }
  3630. if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred)
  3631. direct_dist_scale_factor(h);
  3632. direct_ref_list_init(h);
  3633. return 0;
  3634. }
  3635. static int fill_mbaff_ref_list(H264Context *h){
  3636. int list, i, j;
  3637. for(list=0; list<2; list++){
  3638. for(i=0; i<h->ref_count[list]; i++){
  3639. Picture *frame = &h->ref_list[list][i];
  3640. Picture *field = &h->ref_list[list][16+2*i];
  3641. field[0] = *frame;
  3642. for(j=0; j<3; j++)
  3643. field[0].linesize[j] <<= 1;
  3644. field[1] = field[0];
  3645. for(j=0; j<3; j++)
  3646. field[1].data[j] += frame->linesize[j];
  3647. h->luma_weight[list][16+2*i] = h->luma_weight[list][16+2*i+1] = h->luma_weight[list][i];
  3648. h->luma_offset[list][16+2*i] = h->luma_offset[list][16+2*i+1] = h->luma_offset[list][i];
  3649. for(j=0; j<2; j++){
  3650. h->chroma_weight[list][16+2*i][j] = h->chroma_weight[list][16+2*i+1][j] = h->chroma_weight[list][i][j];
  3651. h->chroma_offset[list][16+2*i][j] = h->chroma_offset[list][16+2*i+1][j] = h->chroma_offset[list][i][j];
  3652. }
  3653. }
  3654. }
  3655. for(j=0; j<h->ref_count[1]; j++){
  3656. for(i=0; i<h->ref_count[0]; i++)
  3657. h->implicit_weight[j][16+2*i] = h->implicit_weight[j][16+2*i+1] = h->implicit_weight[j][i];
  3658. memcpy(h->implicit_weight[16+2*j], h->implicit_weight[j], sizeof(*h->implicit_weight));
  3659. memcpy(h->implicit_weight[16+2*j+1], h->implicit_weight[j], sizeof(*h->implicit_weight));
  3660. }
  3661. }
  3662. static int pred_weight_table(H264Context *h){
  3663. MpegEncContext * const s = &h->s;
  3664. int list, i;
  3665. int luma_def, chroma_def;
  3666. h->use_weight= 0;
  3667. h->use_weight_chroma= 0;
  3668. h->luma_log2_weight_denom= get_ue_golomb(&s->gb);
  3669. h->chroma_log2_weight_denom= get_ue_golomb(&s->gb);
  3670. luma_def = 1<<h->luma_log2_weight_denom;
  3671. chroma_def = 1<<h->chroma_log2_weight_denom;
  3672. for(list=0; list<2; list++){
  3673. for(i=0; i<h->ref_count[list]; i++){
  3674. int luma_weight_flag, chroma_weight_flag;
  3675. luma_weight_flag= get_bits1(&s->gb);
  3676. if(luma_weight_flag){
  3677. h->luma_weight[list][i]= get_se_golomb(&s->gb);
  3678. h->luma_offset[list][i]= get_se_golomb(&s->gb);
  3679. if( h->luma_weight[list][i] != luma_def
  3680. || h->luma_offset[list][i] != 0)
  3681. h->use_weight= 1;
  3682. }else{
  3683. h->luma_weight[list][i]= luma_def;
  3684. h->luma_offset[list][i]= 0;
  3685. }
  3686. chroma_weight_flag= get_bits1(&s->gb);
  3687. if(chroma_weight_flag){
  3688. int j;
  3689. for(j=0; j<2; j++){
  3690. h->chroma_weight[list][i][j]= get_se_golomb(&s->gb);
  3691. h->chroma_offset[list][i][j]= get_se_golomb(&s->gb);
  3692. if( h->chroma_weight[list][i][j] != chroma_def
  3693. || h->chroma_offset[list][i][j] != 0)
  3694. h->use_weight_chroma= 1;
  3695. }
  3696. }else{
  3697. int j;
  3698. for(j=0; j<2; j++){
  3699. h->chroma_weight[list][i][j]= chroma_def;
  3700. h->chroma_offset[list][i][j]= 0;
  3701. }
  3702. }
  3703. }
  3704. if(h->slice_type != B_TYPE) break;
  3705. }
  3706. h->use_weight= h->use_weight || h->use_weight_chroma;
  3707. return 0;
  3708. }
  3709. static void implicit_weight_table(H264Context *h){
  3710. MpegEncContext * const s = &h->s;
  3711. int ref0, ref1;
  3712. int cur_poc = s->current_picture_ptr->poc;
  3713. if( h->ref_count[0] == 1 && h->ref_count[1] == 1
  3714. && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){
  3715. h->use_weight= 0;
  3716. h->use_weight_chroma= 0;
  3717. return;
  3718. }
  3719. h->use_weight= 2;
  3720. h->use_weight_chroma= 2;
  3721. h->luma_log2_weight_denom= 5;
  3722. h->chroma_log2_weight_denom= 5;
  3723. for(ref0=0; ref0 < h->ref_count[0]; ref0++){
  3724. int poc0 = h->ref_list[0][ref0].poc;
  3725. for(ref1=0; ref1 < h->ref_count[1]; ref1++){
  3726. int poc1 = h->ref_list[1][ref1].poc;
  3727. int td = clip(poc1 - poc0, -128, 127);
  3728. if(td){
  3729. int tb = clip(cur_poc - poc0, -128, 127);
  3730. int tx = (16384 + (ABS(td) >> 1)) / td;
  3731. int dist_scale_factor = clip((tb*tx + 32) >> 6, -1024, 1023) >> 2;
  3732. if(dist_scale_factor < -64 || dist_scale_factor > 128)
  3733. h->implicit_weight[ref0][ref1] = 32;
  3734. else
  3735. h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor;
  3736. }else
  3737. h->implicit_weight[ref0][ref1] = 32;
  3738. }
  3739. }
  3740. }
  3741. static inline void unreference_pic(H264Context *h, Picture *pic){
  3742. int i;
  3743. pic->reference=0;
  3744. if(pic == h->delayed_output_pic)
  3745. pic->reference=1;
  3746. else{
  3747. for(i = 0; h->delayed_pic[i]; i++)
  3748. if(pic == h->delayed_pic[i]){
  3749. pic->reference=1;
  3750. break;
  3751. }
  3752. }
  3753. }
  3754. /**
  3755. * instantaneous decoder refresh.
  3756. */
  3757. static void idr(H264Context *h){
  3758. int i;
  3759. for(i=0; i<16; i++){
  3760. if (h->long_ref[i] != NULL) {
  3761. unreference_pic(h, h->long_ref[i]);
  3762. h->long_ref[i]= NULL;
  3763. }
  3764. }
  3765. h->long_ref_count=0;
  3766. for(i=0; i<h->short_ref_count; i++){
  3767. unreference_pic(h, h->short_ref[i]);
  3768. h->short_ref[i]= NULL;
  3769. }
  3770. h->short_ref_count=0;
  3771. }
  3772. /* forget old pics after a seek */
  3773. static void flush_dpb(AVCodecContext *avctx){
  3774. H264Context *h= avctx->priv_data;
  3775. int i;
  3776. for(i=0; i<16; i++) {
  3777. if(h->delayed_pic[i])
  3778. h->delayed_pic[i]->reference= 0;
  3779. h->delayed_pic[i]= NULL;
  3780. }
  3781. if(h->delayed_output_pic)
  3782. h->delayed_output_pic->reference= 0;
  3783. h->delayed_output_pic= NULL;
  3784. idr(h);
  3785. if(h->s.current_picture_ptr)
  3786. h->s.current_picture_ptr->reference= 0;
  3787. }
  3788. /**
  3789. *
  3790. * @return the removed picture or NULL if an error occurs
  3791. */
  3792. static Picture * remove_short(H264Context *h, int frame_num){
  3793. MpegEncContext * const s = &h->s;
  3794. int i;
  3795. if(s->avctx->debug&FF_DEBUG_MMCO)
  3796. av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);
  3797. for(i=0; i<h->short_ref_count; i++){
  3798. Picture *pic= h->short_ref[i];
  3799. if(s->avctx->debug&FF_DEBUG_MMCO)
  3800. av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
  3801. if(pic->frame_num == frame_num){
  3802. h->short_ref[i]= NULL;
  3803. memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*));
  3804. h->short_ref_count--;
  3805. return pic;
  3806. }
  3807. }
  3808. return NULL;
  3809. }
  3810. /**
  3811. *
  3812. * @return the removed picture or NULL if an error occurs
  3813. */
  3814. static Picture * remove_long(H264Context *h, int i){
  3815. Picture *pic;
  3816. pic= h->long_ref[i];
  3817. h->long_ref[i]= NULL;
  3818. if(pic) h->long_ref_count--;
  3819. return pic;
  3820. }
  3821. /**
  3822. * print short term list
  3823. */
  3824. static void print_short_term(H264Context *h) {
  3825. uint32_t i;
  3826. if(h->s.avctx->debug&FF_DEBUG_MMCO) {
  3827. av_log(h->s.avctx, AV_LOG_DEBUG, "short term list:\n");
  3828. for(i=0; i<h->short_ref_count; i++){
  3829. Picture *pic= h->short_ref[i];
  3830. av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]);
  3831. }
  3832. }
  3833. }
  3834. /**
  3835. * print long term list
  3836. */
  3837. static void print_long_term(H264Context *h) {
  3838. uint32_t i;
  3839. if(h->s.avctx->debug&FF_DEBUG_MMCO) {
  3840. av_log(h->s.avctx, AV_LOG_DEBUG, "long term list:\n");
  3841. for(i = 0; i < 16; i++){
  3842. Picture *pic= h->long_ref[i];
  3843. if (pic) {
  3844. av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]);
  3845. }
  3846. }
  3847. }
  3848. }
  3849. /**
  3850. * Executes the reference picture marking (memory management control operations).
  3851. */
  3852. static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){
  3853. MpegEncContext * const s = &h->s;
  3854. int i, j;
  3855. int current_is_long=0;
  3856. Picture *pic;
  3857. if((s->avctx->debug&FF_DEBUG_MMCO) && mmco_count==0)
  3858. av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n");
  3859. for(i=0; i<mmco_count; i++){
  3860. if(s->avctx->debug&FF_DEBUG_MMCO)
  3861. 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);
  3862. switch(mmco[i].opcode){
  3863. case MMCO_SHORT2UNUSED:
  3864. pic= remove_short(h, mmco[i].short_frame_num);
  3865. if(pic)
  3866. unreference_pic(h, pic);
  3867. else if(s->avctx->debug&FF_DEBUG_MMCO)
  3868. av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_short() failure\n");
  3869. break;
  3870. case MMCO_SHORT2LONG:
  3871. pic= remove_long(h, mmco[i].long_index);
  3872. if(pic) unreference_pic(h, pic);
  3873. h->long_ref[ mmco[i].long_index ]= remove_short(h, mmco[i].short_frame_num);
  3874. h->long_ref[ mmco[i].long_index ]->long_ref=1;
  3875. h->long_ref_count++;
  3876. break;
  3877. case MMCO_LONG2UNUSED:
  3878. pic= remove_long(h, mmco[i].long_index);
  3879. if(pic)
  3880. unreference_pic(h, pic);
  3881. else if(s->avctx->debug&FF_DEBUG_MMCO)
  3882. av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_long() failure\n");
  3883. break;
  3884. case MMCO_LONG:
  3885. pic= remove_long(h, mmco[i].long_index);
  3886. if(pic) unreference_pic(h, pic);
  3887. h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr;
  3888. h->long_ref[ mmco[i].long_index ]->long_ref=1;
  3889. h->long_ref_count++;
  3890. current_is_long=1;
  3891. break;
  3892. case MMCO_SET_MAX_LONG:
  3893. assert(mmco[i].long_index <= 16);
  3894. // just remove the long term which index is greater than new max
  3895. for(j = mmco[i].long_index; j<16; j++){
  3896. pic = remove_long(h, j);
  3897. if (pic) unreference_pic(h, pic);
  3898. }
  3899. break;
  3900. case MMCO_RESET:
  3901. while(h->short_ref_count){
  3902. pic= remove_short(h, h->short_ref[0]->frame_num);
  3903. unreference_pic(h, pic);
  3904. }
  3905. for(j = 0; j < 16; j++) {
  3906. pic= remove_long(h, j);
  3907. if(pic) unreference_pic(h, pic);
  3908. }
  3909. break;
  3910. default: assert(0);
  3911. }
  3912. }
  3913. if(!current_is_long){
  3914. pic= remove_short(h, s->current_picture_ptr->frame_num);
  3915. if(pic){
  3916. unreference_pic(h, pic);
  3917. av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
  3918. }
  3919. if(h->short_ref_count)
  3920. memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*));
  3921. h->short_ref[0]= s->current_picture_ptr;
  3922. h->short_ref[0]->long_ref=0;
  3923. h->short_ref_count++;
  3924. }
  3925. print_short_term(h);
  3926. print_long_term(h);
  3927. return 0;
  3928. }
  3929. static int decode_ref_pic_marking(H264Context *h){
  3930. MpegEncContext * const s = &h->s;
  3931. int i;
  3932. if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields
  3933. s->broken_link= get_bits1(&s->gb) -1;
  3934. h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx
  3935. if(h->mmco[0].long_index == -1)
  3936. h->mmco_index= 0;
  3937. else{
  3938. h->mmco[0].opcode= MMCO_LONG;
  3939. h->mmco_index= 1;
  3940. }
  3941. }else{
  3942. if(get_bits1(&s->gb)){ // adaptive_ref_pic_marking_mode_flag
  3943. for(i= 0; i<MAX_MMCO_COUNT; i++) {
  3944. MMCOOpcode opcode= get_ue_golomb(&s->gb);;
  3945. h->mmco[i].opcode= opcode;
  3946. if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){
  3947. 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
  3948. /* if(h->mmco[i].short_frame_num >= h->short_ref_count || h->short_ref[ h->mmco[i].short_frame_num ] == NULL){
  3949. av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco);
  3950. return -1;
  3951. }*/
  3952. }
  3953. if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){
  3954. h->mmco[i].long_index= get_ue_golomb(&s->gb);
  3955. 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){
  3956. av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode);
  3957. return -1;
  3958. }
  3959. }
  3960. if(opcode > MMCO_LONG){
  3961. av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode);
  3962. return -1;
  3963. }
  3964. if(opcode == MMCO_END)
  3965. break;
  3966. }
  3967. h->mmco_index= i;
  3968. }else{
  3969. assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count);
  3970. if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields
  3971. h->mmco[0].opcode= MMCO_SHORT2UNUSED;
  3972. h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num;
  3973. h->mmco_index= 1;
  3974. }else
  3975. h->mmco_index= 0;
  3976. }
  3977. }
  3978. return 0;
  3979. }
  3980. static int init_poc(H264Context *h){
  3981. MpegEncContext * const s = &h->s;
  3982. const int max_frame_num= 1<<h->sps.log2_max_frame_num;
  3983. int field_poc[2];
  3984. if(h->nal_unit_type == NAL_IDR_SLICE){
  3985. h->frame_num_offset= 0;
  3986. }else{
  3987. if(h->frame_num < h->prev_frame_num)
  3988. h->frame_num_offset= h->prev_frame_num_offset + max_frame_num;
  3989. else
  3990. h->frame_num_offset= h->prev_frame_num_offset;
  3991. }
  3992. if(h->sps.poc_type==0){
  3993. const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb;
  3994. if(h->nal_unit_type == NAL_IDR_SLICE){
  3995. h->prev_poc_msb=
  3996. h->prev_poc_lsb= 0;
  3997. }
  3998. if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2)
  3999. h->poc_msb = h->prev_poc_msb + max_poc_lsb;
  4000. else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2)
  4001. h->poc_msb = h->prev_poc_msb - max_poc_lsb;
  4002. else
  4003. h->poc_msb = h->prev_poc_msb;
  4004. //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb);
  4005. field_poc[0] =
  4006. field_poc[1] = h->poc_msb + h->poc_lsb;
  4007. if(s->picture_structure == PICT_FRAME)
  4008. field_poc[1] += h->delta_poc_bottom;
  4009. }else if(h->sps.poc_type==1){
  4010. int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
  4011. int i;
  4012. if(h->sps.poc_cycle_length != 0)
  4013. abs_frame_num = h->frame_num_offset + h->frame_num;
  4014. else
  4015. abs_frame_num = 0;
  4016. if(h->nal_ref_idc==0 && abs_frame_num > 0)
  4017. abs_frame_num--;
  4018. expected_delta_per_poc_cycle = 0;
  4019. for(i=0; i < h->sps.poc_cycle_length; i++)
  4020. expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse
  4021. if(abs_frame_num > 0){
  4022. int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length;
  4023. int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length;
  4024. expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
  4025. for(i = 0; i <= frame_num_in_poc_cycle; i++)
  4026. expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ];
  4027. } else
  4028. expectedpoc = 0;
  4029. if(h->nal_ref_idc == 0)
  4030. expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic;
  4031. field_poc[0] = expectedpoc + h->delta_poc[0];
  4032. field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field;
  4033. if(s->picture_structure == PICT_FRAME)
  4034. field_poc[1] += h->delta_poc[1];
  4035. }else{
  4036. int poc;
  4037. if(h->nal_unit_type == NAL_IDR_SLICE){
  4038. poc= 0;
  4039. }else{
  4040. if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num);
  4041. else poc= 2*(h->frame_num_offset + h->frame_num) - 1;
  4042. }
  4043. field_poc[0]= poc;
  4044. field_poc[1]= poc;
  4045. }
  4046. if(s->picture_structure != PICT_BOTTOM_FIELD)
  4047. s->current_picture_ptr->field_poc[0]= field_poc[0];
  4048. if(s->picture_structure != PICT_TOP_FIELD)
  4049. s->current_picture_ptr->field_poc[1]= field_poc[1];
  4050. if(s->picture_structure == PICT_FRAME) // FIXME field pix?
  4051. s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]);
  4052. return 0;
  4053. }
  4054. /**
  4055. * decodes a slice header.
  4056. * this will allso call MPV_common_init() and frame_start() as needed
  4057. */
  4058. static int decode_slice_header(H264Context *h){
  4059. MpegEncContext * const s = &h->s;
  4060. int first_mb_in_slice, pps_id;
  4061. int num_ref_idx_active_override_flag;
  4062. static const uint8_t slice_type_map[5]= {P_TYPE, B_TYPE, I_TYPE, SP_TYPE, SI_TYPE};
  4063. int slice_type;
  4064. int default_ref_list_done = 0;
  4065. s->current_picture.reference= h->nal_ref_idc != 0;
  4066. s->dropable= h->nal_ref_idc == 0;
  4067. first_mb_in_slice= get_ue_golomb(&s->gb);
  4068. slice_type= get_ue_golomb(&s->gb);
  4069. if(slice_type > 9){
  4070. 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);
  4071. return -1;
  4072. }
  4073. if(slice_type > 4){
  4074. slice_type -= 5;
  4075. h->slice_type_fixed=1;
  4076. }else
  4077. h->slice_type_fixed=0;
  4078. slice_type= slice_type_map[ slice_type ];
  4079. if (slice_type == I_TYPE
  4080. || (h->slice_num != 0 && slice_type == h->slice_type) ) {
  4081. default_ref_list_done = 1;
  4082. }
  4083. h->slice_type= slice_type;
  4084. s->pict_type= h->slice_type; // to make a few old func happy, it's wrong though
  4085. pps_id= get_ue_golomb(&s->gb);
  4086. if(pps_id>255){
  4087. av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");
  4088. return -1;
  4089. }
  4090. h->pps= h->pps_buffer[pps_id];
  4091. if(h->pps.slice_group_count == 0){
  4092. av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n");
  4093. return -1;
  4094. }
  4095. h->sps= h->sps_buffer[ h->pps.sps_id ];
  4096. if(h->sps.log2_max_frame_num == 0){
  4097. av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n");
  4098. return -1;
  4099. }
  4100. if(h->dequant_coeff_pps != pps_id){
  4101. h->dequant_coeff_pps = pps_id;
  4102. init_dequant_tables(h);
  4103. }
  4104. s->mb_width= h->sps.mb_width;
  4105. s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);
  4106. h->b_stride= s->mb_width*4;
  4107. h->b8_stride= s->mb_width*2;
  4108. s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right );
  4109. if(h->sps.frame_mbs_only_flag)
  4110. s->height= 16*s->mb_height - 2*(h->sps.crop_top + h->sps.crop_bottom);
  4111. else
  4112. s->height= 16*s->mb_height - 4*(h->sps.crop_top + h->sps.crop_bottom); //FIXME recheck
  4113. if (s->context_initialized
  4114. && ( s->width != s->avctx->width || s->height != s->avctx->height)) {
  4115. free_tables(h);
  4116. MPV_common_end(s);
  4117. }
  4118. if (!s->context_initialized) {
  4119. if (MPV_common_init(s) < 0)
  4120. return -1;
  4121. if(s->dsp.h264_idct_add == ff_h264_idct_add_c){ //FIXME little ugly
  4122. memcpy(h->zigzag_scan, zigzag_scan, 16*sizeof(uint8_t));
  4123. memcpy(h-> field_scan, field_scan, 16*sizeof(uint8_t));
  4124. }else{
  4125. int i;
  4126. for(i=0; i<16; i++){
  4127. #define T(x) (x>>2) | ((x<<2) & 0xF)
  4128. h->zigzag_scan[i] = T(zigzag_scan[i]);
  4129. h-> field_scan[i] = T( field_scan[i]);
  4130. #undef T
  4131. }
  4132. }
  4133. if(s->dsp.h264_idct8_add == ff_h264_idct8_add_c){
  4134. memcpy(h->zigzag_scan8x8, zigzag_scan8x8, 64*sizeof(uint8_t));
  4135. memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t));
  4136. memcpy(h->field_scan8x8, field_scan8x8, 64*sizeof(uint8_t));
  4137. memcpy(h->field_scan8x8_cavlc, field_scan8x8_cavlc, 64*sizeof(uint8_t));
  4138. }else{
  4139. int i;
  4140. for(i=0; i<64; i++){
  4141. #define T(x) (x>>3) | ((x&7)<<3)
  4142. h->zigzag_scan8x8[i] = T(zigzag_scan8x8[i]);
  4143. h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]);
  4144. h->field_scan8x8[i] = T(field_scan8x8[i]);
  4145. h->field_scan8x8_cavlc[i] = T(field_scan8x8_cavlc[i]);
  4146. #undef T
  4147. }
  4148. }
  4149. if(h->sps.transform_bypass){ //FIXME same ugly
  4150. h->zigzag_scan_q0 = zigzag_scan;
  4151. h->zigzag_scan8x8_q0 = zigzag_scan8x8;
  4152. h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc;
  4153. h->field_scan_q0 = field_scan;
  4154. h->field_scan8x8_q0 = field_scan8x8;
  4155. h->field_scan8x8_cavlc_q0 = field_scan8x8_cavlc;
  4156. }else{
  4157. h->zigzag_scan_q0 = h->zigzag_scan;
  4158. h->zigzag_scan8x8_q0 = h->zigzag_scan8x8;
  4159. h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc;
  4160. h->field_scan_q0 = h->field_scan;
  4161. h->field_scan8x8_q0 = h->field_scan8x8;
  4162. h->field_scan8x8_cavlc_q0 = h->field_scan8x8_cavlc;
  4163. }
  4164. alloc_tables(h);
  4165. s->avctx->width = s->width;
  4166. s->avctx->height = s->height;
  4167. s->avctx->sample_aspect_ratio= h->sps.sar;
  4168. if(!s->avctx->sample_aspect_ratio.den)
  4169. s->avctx->sample_aspect_ratio.den = 1;
  4170. if(h->sps.timing_info_present_flag){
  4171. s->avctx->time_base= (AVRational){h->sps.num_units_in_tick * 2, h->sps.time_scale};
  4172. if(h->x264_build > 0 && h->x264_build < 44)
  4173. s->avctx->time_base.den *= 2;
  4174. av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,
  4175. s->avctx->time_base.num, s->avctx->time_base.den, 1<<30);
  4176. }
  4177. }
  4178. if(h->slice_num == 0){
  4179. if(frame_start(h) < 0)
  4180. return -1;
  4181. }
  4182. s->current_picture_ptr->frame_num= //FIXME frame_num cleanup
  4183. h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num);
  4184. h->mb_mbaff = 0;
  4185. h->mb_aff_frame = 0;
  4186. if(h->sps.frame_mbs_only_flag){
  4187. s->picture_structure= PICT_FRAME;
  4188. }else{
  4189. if(get_bits1(&s->gb)) { //field_pic_flag
  4190. s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag
  4191. av_log(h->s.avctx, AV_LOG_ERROR, "PAFF interlacing is not implemented\n");
  4192. } else {
  4193. s->picture_structure= PICT_FRAME;
  4194. h->mb_aff_frame = h->sps.mb_aff;
  4195. }
  4196. }
  4197. s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width;
  4198. s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << h->mb_aff_frame;
  4199. if(s->mb_y >= s->mb_height){
  4200. return -1;
  4201. }
  4202. if(s->picture_structure==PICT_FRAME){
  4203. h->curr_pic_num= h->frame_num;
  4204. h->max_pic_num= 1<< h->sps.log2_max_frame_num;
  4205. }else{
  4206. h->curr_pic_num= 2*h->frame_num;
  4207. h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1);
  4208. }
  4209. if(h->nal_unit_type == NAL_IDR_SLICE){
  4210. get_ue_golomb(&s->gb); /* idr_pic_id */
  4211. }
  4212. if(h->sps.poc_type==0){
  4213. h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb);
  4214. if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){
  4215. h->delta_poc_bottom= get_se_golomb(&s->gb);
  4216. }
  4217. }
  4218. if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){
  4219. h->delta_poc[0]= get_se_golomb(&s->gb);
  4220. if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME)
  4221. h->delta_poc[1]= get_se_golomb(&s->gb);
  4222. }
  4223. init_poc(h);
  4224. if(h->pps.redundant_pic_cnt_present){
  4225. h->redundant_pic_count= get_ue_golomb(&s->gb);
  4226. }
  4227. //set defaults, might be overriden a few line later
  4228. h->ref_count[0]= h->pps.ref_count[0];
  4229. h->ref_count[1]= h->pps.ref_count[1];
  4230. if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){
  4231. if(h->slice_type == B_TYPE){
  4232. h->direct_spatial_mv_pred= get_bits1(&s->gb);
  4233. if(h->sps.mb_aff && h->direct_spatial_mv_pred)
  4234. av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + spatial direct mode is not implemented\n");
  4235. }
  4236. num_ref_idx_active_override_flag= get_bits1(&s->gb);
  4237. if(num_ref_idx_active_override_flag){
  4238. h->ref_count[0]= get_ue_golomb(&s->gb) + 1;
  4239. if(h->slice_type==B_TYPE)
  4240. h->ref_count[1]= get_ue_golomb(&s->gb) + 1;
  4241. if(h->ref_count[0] > 32 || h->ref_count[1] > 32){
  4242. av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");
  4243. return -1;
  4244. }
  4245. }
  4246. }
  4247. if(!default_ref_list_done){
  4248. fill_default_ref_list(h);
  4249. }
  4250. if(decode_ref_pic_list_reordering(h) < 0)
  4251. return -1;
  4252. if( (h->pps.weighted_pred && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE ))
  4253. || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) )
  4254. pred_weight_table(h);
  4255. else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE)
  4256. implicit_weight_table(h);
  4257. else
  4258. h->use_weight = 0;
  4259. if(s->current_picture.reference)
  4260. decode_ref_pic_marking(h);
  4261. if(FRAME_MBAFF)
  4262. fill_mbaff_ref_list(h);
  4263. if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE && h->pps.cabac )
  4264. h->cabac_init_idc = get_ue_golomb(&s->gb);
  4265. h->last_qscale_diff = 0;
  4266. s->qscale = h->pps.init_qp + get_se_golomb(&s->gb);
  4267. if(s->qscale<0 || s->qscale>51){
  4268. av_log(s->avctx, AV_LOG_ERROR, "QP %d out of range\n", s->qscale);
  4269. return -1;
  4270. }
  4271. h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale);
  4272. //FIXME qscale / qp ... stuff
  4273. if(h->slice_type == SP_TYPE){
  4274. get_bits1(&s->gb); /* sp_for_switch_flag */
  4275. }
  4276. if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){
  4277. get_se_golomb(&s->gb); /* slice_qs_delta */
  4278. }
  4279. h->deblocking_filter = 1;
  4280. h->slice_alpha_c0_offset = 0;
  4281. h->slice_beta_offset = 0;
  4282. if( h->pps.deblocking_filter_parameters_present ) {
  4283. h->deblocking_filter= get_ue_golomb(&s->gb);
  4284. if(h->deblocking_filter < 2)
  4285. h->deblocking_filter^= 1; // 1<->0
  4286. if( h->deblocking_filter ) {
  4287. h->slice_alpha_c0_offset = get_se_golomb(&s->gb) << 1;
  4288. h->slice_beta_offset = get_se_golomb(&s->gb) << 1;
  4289. }
  4290. }
  4291. if( s->avctx->skip_loop_filter >= AVDISCARD_ALL
  4292. ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type != I_TYPE)
  4293. ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && h->slice_type == B_TYPE)
  4294. ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
  4295. h->deblocking_filter= 0;
  4296. #if 0 //FMO
  4297. if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5)
  4298. slice_group_change_cycle= get_bits(&s->gb, ?);
  4299. #endif
  4300. h->slice_num++;
  4301. h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16;
  4302. h->emu_edge_height= FRAME_MBAFF ? 0 : h->emu_edge_width;
  4303. if(s->avctx->debug&FF_DEBUG_PICT_INFO){
  4304. 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",
  4305. h->slice_num,
  4306. (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"),
  4307. first_mb_in_slice,
  4308. av_get_pict_type_char(h->slice_type),
  4309. pps_id, h->frame_num,
  4310. s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1],
  4311. h->ref_count[0], h->ref_count[1],
  4312. s->qscale,
  4313. h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2,
  4314. h->use_weight,
  4315. h->use_weight==1 && h->use_weight_chroma ? "c" : ""
  4316. );
  4317. }
  4318. return 0;
  4319. }
  4320. /**
  4321. *
  4322. */
  4323. static inline int get_level_prefix(GetBitContext *gb){
  4324. unsigned int buf;
  4325. int log;
  4326. OPEN_READER(re, gb);
  4327. UPDATE_CACHE(re, gb);
  4328. buf=GET_CACHE(re, gb);
  4329. log= 32 - av_log2(buf);
  4330. #ifdef TRACE
  4331. print_bin(buf>>(32-log), log);
  4332. 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__);
  4333. #endif
  4334. LAST_SKIP_BITS(re, gb, log);
  4335. CLOSE_READER(re, gb);
  4336. return log-1;
  4337. }
  4338. static inline int get_dct8x8_allowed(H264Context *h){
  4339. int i;
  4340. for(i=0; i<4; i++){
  4341. if(!IS_SUB_8X8(h->sub_mb_type[i])
  4342. || (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i])))
  4343. return 0;
  4344. }
  4345. return 1;
  4346. }
  4347. /**
  4348. * decodes a residual block.
  4349. * @param n block index
  4350. * @param scantable scantable
  4351. * @param max_coeff number of coefficients in the block
  4352. * @return <0 if an error occured
  4353. */
  4354. static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
  4355. MpegEncContext * const s = &h->s;
  4356. 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};
  4357. int level[16];
  4358. int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before;
  4359. //FIXME put trailing_onex into the context
  4360. if(n == CHROMA_DC_BLOCK_INDEX){
  4361. coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
  4362. total_coeff= coeff_token>>2;
  4363. }else{
  4364. if(n == LUMA_DC_BLOCK_INDEX){
  4365. total_coeff= pred_non_zero_count(h, 0);
  4366. coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
  4367. total_coeff= coeff_token>>2;
  4368. }else{
  4369. total_coeff= pred_non_zero_count(h, n);
  4370. coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
  4371. total_coeff= coeff_token>>2;
  4372. h->non_zero_count_cache[ scan8[n] ]= total_coeff;
  4373. }
  4374. }
  4375. //FIXME set last_non_zero?
  4376. if(total_coeff==0)
  4377. return 0;
  4378. trailing_ones= coeff_token&3;
  4379. tprintf("trailing:%d, total:%d\n", trailing_ones, total_coeff);
  4380. assert(total_coeff<=16);
  4381. for(i=0; i<trailing_ones; i++){
  4382. level[i]= 1 - 2*get_bits1(gb);
  4383. }
  4384. if(i<total_coeff) {
  4385. int level_code, mask;
  4386. int suffix_length = total_coeff > 10 && trailing_ones < 3;
  4387. int prefix= get_level_prefix(gb);
  4388. //first coefficient has suffix_length equal to 0 or 1
  4389. if(prefix<14){ //FIXME try to build a large unified VLC table for all this
  4390. if(suffix_length)
  4391. level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
  4392. else
  4393. level_code= (prefix<<suffix_length); //part
  4394. }else if(prefix==14){
  4395. if(suffix_length)
  4396. level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
  4397. else
  4398. level_code= prefix + get_bits(gb, 4); //part
  4399. }else if(prefix==15){
  4400. level_code= (prefix<<suffix_length) + get_bits(gb, 12); //part
  4401. if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense
  4402. }else{
  4403. av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y);
  4404. return -1;
  4405. }
  4406. if(trailing_ones < 3) level_code += 2;
  4407. suffix_length = 1;
  4408. if(level_code > 5)
  4409. suffix_length++;
  4410. mask= -(level_code&1);
  4411. level[i]= (((2+level_code)>>1) ^ mask) - mask;
  4412. i++;
  4413. //remaining coefficients have suffix_length > 0
  4414. for(;i<total_coeff;i++) {
  4415. static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX };
  4416. prefix = get_level_prefix(gb);
  4417. if(prefix<15){
  4418. level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
  4419. }else if(prefix==15){
  4420. level_code = (prefix<<suffix_length) + get_bits(gb, 12);
  4421. }else{
  4422. av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y);
  4423. return -1;
  4424. }
  4425. mask= -(level_code&1);
  4426. level[i]= (((2+level_code)>>1) ^ mask) - mask;
  4427. if(level_code > suffix_limit[suffix_length])
  4428. suffix_length++;
  4429. }
  4430. }
  4431. if(total_coeff == max_coeff)
  4432. zeros_left=0;
  4433. else{
  4434. if(n == CHROMA_DC_BLOCK_INDEX)
  4435. zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
  4436. else
  4437. zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1);
  4438. }
  4439. coeff_num = zeros_left + total_coeff - 1;
  4440. j = scantable[coeff_num];
  4441. if(n > 24){
  4442. block[j] = level[0];
  4443. for(i=1;i<total_coeff;i++) {
  4444. if(zeros_left <= 0)
  4445. run_before = 0;
  4446. else if(zeros_left < 7){
  4447. run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);
  4448. }else{
  4449. run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
  4450. }
  4451. zeros_left -= run_before;
  4452. coeff_num -= 1 + run_before;
  4453. j= scantable[ coeff_num ];
  4454. block[j]= level[i];
  4455. }
  4456. }else{
  4457. block[j] = (level[0] * qmul[j] + 32)>>6;
  4458. for(i=1;i<total_coeff;i++) {
  4459. if(zeros_left <= 0)
  4460. run_before = 0;
  4461. else if(zeros_left < 7){
  4462. run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);
  4463. }else{
  4464. run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
  4465. }
  4466. zeros_left -= run_before;
  4467. coeff_num -= 1 + run_before;
  4468. j= scantable[ coeff_num ];
  4469. block[j]= (level[i] * qmul[j] + 32)>>6;
  4470. }
  4471. }
  4472. if(zeros_left<0){
  4473. av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);
  4474. return -1;
  4475. }
  4476. return 0;
  4477. }
  4478. static void predict_field_decoding_flag(H264Context *h){
  4479. MpegEncContext * const s = &h->s;
  4480. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  4481. int mb_type = (h->slice_table[mb_xy-1] == h->slice_num)
  4482. ? s->current_picture.mb_type[mb_xy-1]
  4483. : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num)
  4484. ? s->current_picture.mb_type[mb_xy-s->mb_stride]
  4485. : 0;
  4486. h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
  4487. }
  4488. /**
  4489. * decodes a P_SKIP or B_SKIP macroblock
  4490. */
  4491. static void decode_mb_skip(H264Context *h){
  4492. MpegEncContext * const s = &h->s;
  4493. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  4494. int mb_type=0;
  4495. memset(h->non_zero_count[mb_xy], 0, 16);
  4496. memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui
  4497. if(MB_FIELD)
  4498. mb_type|= MB_TYPE_INTERLACED;
  4499. if( h->slice_type == B_TYPE )
  4500. {
  4501. // just for fill_caches. pred_direct_motion will set the real mb_type
  4502. mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP;
  4503. fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ...
  4504. pred_direct_motion(h, &mb_type);
  4505. if(h->pps.cabac){
  4506. fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
  4507. fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
  4508. }
  4509. }
  4510. else
  4511. {
  4512. int mx, my;
  4513. mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP;
  4514. fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ...
  4515. pred_pskip_motion(h, &mx, &my);
  4516. fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);
  4517. fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4);
  4518. if(h->pps.cabac)
  4519. fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
  4520. }
  4521. write_back_motion(h, mb_type);
  4522. s->current_picture.mb_type[mb_xy]= mb_type|MB_TYPE_SKIP;
  4523. s->current_picture.qscale_table[mb_xy]= s->qscale;
  4524. h->slice_table[ mb_xy ]= h->slice_num;
  4525. h->prev_mb_skipped= 1;
  4526. }
  4527. /**
  4528. * decodes a macroblock
  4529. * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
  4530. */
  4531. static int decode_mb_cavlc(H264Context *h){
  4532. MpegEncContext * const s = &h->s;
  4533. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  4534. int mb_type, partition_count, cbp;
  4535. int dct8x8_allowed= h->pps.transform_8x8_mode;
  4536. s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong?
  4537. tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
  4538. cbp = 0; /* avoid warning. FIXME: find a solution without slowing
  4539. down the code */
  4540. if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){
  4541. if(s->mb_skip_run==-1)
  4542. s->mb_skip_run= get_ue_golomb(&s->gb);
  4543. if (s->mb_skip_run--) {
  4544. if(FRAME_MBAFF && (s->mb_y&1) == 0){
  4545. if(s->mb_skip_run==0)
  4546. h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
  4547. else
  4548. predict_field_decoding_flag(h);
  4549. }
  4550. decode_mb_skip(h);
  4551. return 0;
  4552. }
  4553. }
  4554. if(FRAME_MBAFF){
  4555. if( (s->mb_y&1) == 0 )
  4556. h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
  4557. }else
  4558. h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME);
  4559. h->prev_mb_skipped= 0;
  4560. mb_type= get_ue_golomb(&s->gb);
  4561. if(h->slice_type == B_TYPE){
  4562. if(mb_type < 23){
  4563. partition_count= b_mb_type_info[mb_type].partition_count;
  4564. mb_type= b_mb_type_info[mb_type].type;
  4565. }else{
  4566. mb_type -= 23;
  4567. goto decode_intra_mb;
  4568. }
  4569. }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){
  4570. if(mb_type < 5){
  4571. partition_count= p_mb_type_info[mb_type].partition_count;
  4572. mb_type= p_mb_type_info[mb_type].type;
  4573. }else{
  4574. mb_type -= 5;
  4575. goto decode_intra_mb;
  4576. }
  4577. }else{
  4578. assert(h->slice_type == I_TYPE);
  4579. decode_intra_mb:
  4580. if(mb_type > 25){
  4581. av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice to large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);
  4582. return -1;
  4583. }
  4584. partition_count=0;
  4585. cbp= i_mb_type_info[mb_type].cbp;
  4586. h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
  4587. mb_type= i_mb_type_info[mb_type].type;
  4588. }
  4589. if(MB_FIELD)
  4590. mb_type |= MB_TYPE_INTERLACED;
  4591. h->slice_table[ mb_xy ]= h->slice_num;
  4592. if(IS_INTRA_PCM(mb_type)){
  4593. unsigned int x, y;
  4594. // we assume these blocks are very rare so we dont optimize it
  4595. align_get_bits(&s->gb);
  4596. // The pixels are stored in the same order as levels in h->mb array.
  4597. for(y=0; y<16; y++){
  4598. const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3);
  4599. for(x=0; x<16; x++){
  4600. tprintf("LUMA ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8));
  4601. h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8);
  4602. }
  4603. }
  4604. for(y=0; y<8; y++){
  4605. const int index= 256 + 4*(y&3) + 32*(y>>2);
  4606. for(x=0; x<8; x++){
  4607. tprintf("CHROMA U ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8));
  4608. h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8);
  4609. }
  4610. }
  4611. for(y=0; y<8; y++){
  4612. const int index= 256 + 64 + 4*(y&3) + 32*(y>>2);
  4613. for(x=0; x<8; x++){
  4614. tprintf("CHROMA V ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8));
  4615. h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8);
  4616. }
  4617. }
  4618. // In deblocking, the quantizer is 0
  4619. s->current_picture.qscale_table[mb_xy]= 0;
  4620. h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, 0);
  4621. // All coeffs are present
  4622. memset(h->non_zero_count[mb_xy], 16, 16);
  4623. s->current_picture.mb_type[mb_xy]= mb_type;
  4624. return 0;
  4625. }
  4626. if(MB_MBAFF){
  4627. h->ref_count[0] <<= 1;
  4628. h->ref_count[1] <<= 1;
  4629. }
  4630. fill_caches(h, mb_type, 0);
  4631. //mb_pred
  4632. if(IS_INTRA(mb_type)){
  4633. // init_top_left_availability(h);
  4634. if(IS_INTRA4x4(mb_type)){
  4635. int i;
  4636. int di = 1;
  4637. if(dct8x8_allowed && get_bits1(&s->gb)){
  4638. mb_type |= MB_TYPE_8x8DCT;
  4639. di = 4;
  4640. }
  4641. // fill_intra4x4_pred_table(h);
  4642. for(i=0; i<16; i+=di){
  4643. const int mode_coded= !get_bits1(&s->gb);
  4644. const int predicted_mode= pred_intra_mode(h, i);
  4645. int mode;
  4646. if(mode_coded){
  4647. const int rem_mode= get_bits(&s->gb, 3);
  4648. if(rem_mode<predicted_mode)
  4649. mode= rem_mode;
  4650. else
  4651. mode= rem_mode + 1;
  4652. }else{
  4653. mode= predicted_mode;
  4654. }
  4655. if(di==4)
  4656. fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
  4657. else
  4658. h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
  4659. }
  4660. write_back_intra_pred_mode(h);
  4661. if( check_intra4x4_pred_mode(h) < 0)
  4662. return -1;
  4663. }else{
  4664. h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode);
  4665. if(h->intra16x16_pred_mode < 0)
  4666. return -1;
  4667. }
  4668. h->chroma_pred_mode= get_ue_golomb(&s->gb);
  4669. h->chroma_pred_mode= check_intra_pred_mode(h, h->chroma_pred_mode);
  4670. if(h->chroma_pred_mode < 0)
  4671. return -1;
  4672. }else if(partition_count==4){
  4673. int i, j, sub_partition_count[4], list, ref[2][4];
  4674. if(h->slice_type == B_TYPE){
  4675. for(i=0; i<4; i++){
  4676. h->sub_mb_type[i]= get_ue_golomb(&s->gb);
  4677. if(h->sub_mb_type[i] >=13){
  4678. 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);
  4679. return -1;
  4680. }
  4681. sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
  4682. h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
  4683. }
  4684. if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1])
  4685. || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {
  4686. pred_direct_motion(h, &mb_type);
  4687. h->ref_cache[0][scan8[4]] =
  4688. h->ref_cache[1][scan8[4]] =
  4689. h->ref_cache[0][scan8[12]] =
  4690. h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
  4691. }
  4692. }else{
  4693. assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ?
  4694. for(i=0; i<4; i++){
  4695. h->sub_mb_type[i]= get_ue_golomb(&s->gb);
  4696. if(h->sub_mb_type[i] >=4){
  4697. 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);
  4698. return -1;
  4699. }
  4700. sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
  4701. h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
  4702. }
  4703. }
  4704. for(list=0; list<2; list++){
  4705. int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
  4706. if(ref_count == 0) continue;
  4707. for(i=0; i<4; i++){
  4708. if(IS_DIRECT(h->sub_mb_type[i])) continue;
  4709. if(IS_DIR(h->sub_mb_type[i], 0, list)){
  4710. ref[list][i] = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip?
  4711. }else{
  4712. //FIXME
  4713. ref[list][i] = -1;
  4714. }
  4715. }
  4716. }
  4717. if(dct8x8_allowed)
  4718. dct8x8_allowed = get_dct8x8_allowed(h);
  4719. for(list=0; list<2; list++){
  4720. const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
  4721. if(ref_count == 0) continue;
  4722. for(i=0; i<4; i++){
  4723. if(IS_DIRECT(h->sub_mb_type[i])) {
  4724. h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
  4725. continue;
  4726. }
  4727. h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]=
  4728. h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
  4729. if(IS_DIR(h->sub_mb_type[i], 0, list)){
  4730. const int sub_mb_type= h->sub_mb_type[i];
  4731. const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
  4732. for(j=0; j<sub_partition_count[i]; j++){
  4733. int mx, my;
  4734. const int index= 4*i + block_width*j;
  4735. int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
  4736. pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
  4737. mx += get_se_golomb(&s->gb);
  4738. my += get_se_golomb(&s->gb);
  4739. tprintf("final mv:%d %d\n", mx, my);
  4740. if(IS_SUB_8X8(sub_mb_type)){
  4741. mv_cache[ 0 ][0]= mv_cache[ 1 ][0]=
  4742. mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
  4743. mv_cache[ 0 ][1]= mv_cache[ 1 ][1]=
  4744. mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
  4745. }else if(IS_SUB_8X4(sub_mb_type)){
  4746. mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx;
  4747. mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my;
  4748. }else if(IS_SUB_4X8(sub_mb_type)){
  4749. mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx;
  4750. mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my;
  4751. }else{
  4752. assert(IS_SUB_4X4(sub_mb_type));
  4753. mv_cache[ 0 ][0]= mx;
  4754. mv_cache[ 0 ][1]= my;
  4755. }
  4756. }
  4757. }else{
  4758. uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
  4759. p[0] = p[1]=
  4760. p[8] = p[9]= 0;
  4761. }
  4762. }
  4763. }
  4764. }else if(IS_DIRECT(mb_type)){
  4765. pred_direct_motion(h, &mb_type);
  4766. dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
  4767. }else{
  4768. int list, mx, my, i;
  4769. //FIXME we should set ref_idx_l? to 0 if we use that later ...
  4770. if(IS_16X16(mb_type)){
  4771. for(list=0; list<2; list++){
  4772. if(h->ref_count[list]>0){
  4773. if(IS_DIR(mb_type, 0, list)){
  4774. const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
  4775. fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
  4776. }else
  4777. fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (LIST_NOT_USED&0xFF), 1);
  4778. }
  4779. }
  4780. for(list=0; list<2; list++){
  4781. if(IS_DIR(mb_type, 0, list)){
  4782. pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
  4783. mx += get_se_golomb(&s->gb);
  4784. my += get_se_golomb(&s->gb);
  4785. tprintf("final mv:%d %d\n", mx, my);
  4786. fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
  4787. }else
  4788. fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
  4789. }
  4790. }
  4791. else if(IS_16X8(mb_type)){
  4792. for(list=0; list<2; list++){
  4793. if(h->ref_count[list]>0){
  4794. for(i=0; i<2; i++){
  4795. if(IS_DIR(mb_type, i, list)){
  4796. const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
  4797. fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
  4798. }else
  4799. fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
  4800. }
  4801. }
  4802. }
  4803. for(list=0; list<2; list++){
  4804. for(i=0; i<2; i++){
  4805. if(IS_DIR(mb_type, i, list)){
  4806. pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
  4807. mx += get_se_golomb(&s->gb);
  4808. my += get_se_golomb(&s->gb);
  4809. tprintf("final mv:%d %d\n", mx, my);
  4810. fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
  4811. }else
  4812. fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
  4813. }
  4814. }
  4815. }else{
  4816. assert(IS_8X16(mb_type));
  4817. for(list=0; list<2; list++){
  4818. if(h->ref_count[list]>0){
  4819. for(i=0; i<2; i++){
  4820. if(IS_DIR(mb_type, i, list)){ //FIXME optimize
  4821. const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
  4822. fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
  4823. }else
  4824. fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
  4825. }
  4826. }
  4827. }
  4828. for(list=0; list<2; list++){
  4829. for(i=0; i<2; i++){
  4830. if(IS_DIR(mb_type, i, list)){
  4831. pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
  4832. mx += get_se_golomb(&s->gb);
  4833. my += get_se_golomb(&s->gb);
  4834. tprintf("final mv:%d %d\n", mx, my);
  4835. fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
  4836. }else
  4837. fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
  4838. }
  4839. }
  4840. }
  4841. }
  4842. if(IS_INTER(mb_type))
  4843. write_back_motion(h, mb_type);
  4844. if(!IS_INTRA16x16(mb_type)){
  4845. cbp= get_ue_golomb(&s->gb);
  4846. if(cbp > 47){
  4847. av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%d) at %d %d\n", cbp, s->mb_x, s->mb_y);
  4848. return -1;
  4849. }
  4850. if(IS_INTRA4x4(mb_type))
  4851. cbp= golomb_to_intra4x4_cbp[cbp];
  4852. else
  4853. cbp= golomb_to_inter_cbp[cbp];
  4854. }
  4855. if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
  4856. if(get_bits1(&s->gb))
  4857. mb_type |= MB_TYPE_8x8DCT;
  4858. }
  4859. s->current_picture.mb_type[mb_xy]= mb_type;
  4860. if(cbp || IS_INTRA16x16(mb_type)){
  4861. int i8x8, i4x4, chroma_idx;
  4862. int chroma_qp, dquant;
  4863. GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
  4864. const uint8_t *scan, *scan8x8, *dc_scan;
  4865. // fill_non_zero_count_cache(h);
  4866. if(IS_INTERLACED(mb_type)){
  4867. scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
  4868. scan= s->qscale ? h->field_scan : h->field_scan_q0;
  4869. dc_scan= luma_dc_field_scan;
  4870. }else{
  4871. scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
  4872. scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
  4873. dc_scan= luma_dc_zigzag_scan;
  4874. }
  4875. dquant= get_se_golomb(&s->gb);
  4876. if( dquant > 25 || dquant < -26 ){
  4877. av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
  4878. return -1;
  4879. }
  4880. s->qscale += dquant;
  4881. if(((unsigned)s->qscale) > 51){
  4882. if(s->qscale<0) s->qscale+= 52;
  4883. else s->qscale-= 52;
  4884. }
  4885. h->chroma_qp= chroma_qp= get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale);
  4886. if(IS_INTRA16x16(mb_type)){
  4887. if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){
  4888. return -1; //FIXME continue if partitioned and other return -1 too
  4889. }
  4890. assert((cbp&15) == 0 || (cbp&15) == 15);
  4891. if(cbp&15){
  4892. for(i8x8=0; i8x8<4; i8x8++){
  4893. for(i4x4=0; i4x4<4; i4x4++){
  4894. const int index= i4x4 + 4*i8x8;
  4895. if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){
  4896. return -1;
  4897. }
  4898. }
  4899. }
  4900. }else{
  4901. fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
  4902. }
  4903. }else{
  4904. for(i8x8=0; i8x8<4; i8x8++){
  4905. if(cbp & (1<<i8x8)){
  4906. if(IS_8x8DCT(mb_type)){
  4907. DCTELEM *buf = &h->mb[64*i8x8];
  4908. uint8_t *nnz;
  4909. for(i4x4=0; i4x4<4; i4x4++){
  4910. if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4,
  4911. h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 )
  4912. return -1;
  4913. }
  4914. nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
  4915. nnz[0] += nnz[1] + nnz[8] + nnz[9];
  4916. }else{
  4917. for(i4x4=0; i4x4<4; i4x4++){
  4918. const int index= i4x4 + 4*i8x8;
  4919. if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){
  4920. return -1;
  4921. }
  4922. }
  4923. }
  4924. }else{
  4925. uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
  4926. nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
  4927. }
  4928. }
  4929. }
  4930. if(cbp&0x30){
  4931. for(chroma_idx=0; chroma_idx<2; chroma_idx++)
  4932. if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){
  4933. return -1;
  4934. }
  4935. }
  4936. if(cbp&0x20){
  4937. for(chroma_idx=0; chroma_idx<2; chroma_idx++){
  4938. for(i4x4=0; i4x4<4; i4x4++){
  4939. const int index= 16 + 4*chroma_idx + i4x4;
  4940. 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){
  4941. return -1;
  4942. }
  4943. }
  4944. }
  4945. }else{
  4946. uint8_t * const nnz= &h->non_zero_count_cache[0];
  4947. nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
  4948. nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
  4949. }
  4950. }else{
  4951. uint8_t * const nnz= &h->non_zero_count_cache[0];
  4952. fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
  4953. nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
  4954. nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
  4955. }
  4956. s->current_picture.qscale_table[mb_xy]= s->qscale;
  4957. write_back_non_zero_count(h);
  4958. if(MB_MBAFF){
  4959. h->ref_count[0] >>= 1;
  4960. h->ref_count[1] >>= 1;
  4961. }
  4962. return 0;
  4963. }
  4964. static int decode_cabac_field_decoding_flag(H264Context *h) {
  4965. MpegEncContext * const s = &h->s;
  4966. const int mb_x = s->mb_x;
  4967. const int mb_y = s->mb_y & ~1;
  4968. const int mba_xy = mb_x - 1 + mb_y *s->mb_stride;
  4969. const int mbb_xy = mb_x + (mb_y-2)*s->mb_stride;
  4970. unsigned int ctx = 0;
  4971. if( h->slice_table[mba_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) {
  4972. ctx += 1;
  4973. }
  4974. if( h->slice_table[mbb_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) {
  4975. ctx += 1;
  4976. }
  4977. return get_cabac( &h->cabac, &h->cabac_state[70 + ctx] );
  4978. }
  4979. static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
  4980. uint8_t *state= &h->cabac_state[ctx_base];
  4981. int mb_type;
  4982. if(intra_slice){
  4983. MpegEncContext * const s = &h->s;
  4984. const int mba_xy = h->left_mb_xy[0];
  4985. const int mbb_xy = h->top_mb_xy;
  4986. int ctx=0;
  4987. if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) )
  4988. ctx++;
  4989. if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) )
  4990. ctx++;
  4991. if( get_cabac( &h->cabac, &state[ctx] ) == 0 )
  4992. return 0; /* I4x4 */
  4993. state += 2;
  4994. }else{
  4995. if( get_cabac( &h->cabac, &state[0] ) == 0 )
  4996. return 0; /* I4x4 */
  4997. }
  4998. if( get_cabac_terminate( &h->cabac ) )
  4999. return 25; /* PCM */
  5000. mb_type = 1; /* I16x16 */
  5001. mb_type += 12 * get_cabac( &h->cabac, &state[1] ); /* cbp_luma != 0 */
  5002. if( get_cabac( &h->cabac, &state[2] ) ) /* cbp_chroma */
  5003. mb_type += 4 + 4 * get_cabac( &h->cabac, &state[2+intra_slice] );
  5004. mb_type += 2 * get_cabac( &h->cabac, &state[3+intra_slice] );
  5005. mb_type += 1 * get_cabac( &h->cabac, &state[3+2*intra_slice] );
  5006. return mb_type;
  5007. }
  5008. static int decode_cabac_mb_type( H264Context *h ) {
  5009. MpegEncContext * const s = &h->s;
  5010. if( h->slice_type == I_TYPE ) {
  5011. return decode_cabac_intra_mb_type(h, 3, 1);
  5012. } else if( h->slice_type == P_TYPE ) {
  5013. if( get_cabac( &h->cabac, &h->cabac_state[14] ) == 0 ) {
  5014. /* P-type */
  5015. if( get_cabac( &h->cabac, &h->cabac_state[15] ) == 0 ) {
  5016. /* P_L0_D16x16, P_8x8 */
  5017. return 3 * get_cabac( &h->cabac, &h->cabac_state[16] );
  5018. } else {
  5019. /* P_L0_D8x16, P_L0_D16x8 */
  5020. return 2 - get_cabac( &h->cabac, &h->cabac_state[17] );
  5021. }
  5022. } else {
  5023. return decode_cabac_intra_mb_type(h, 17, 0) + 5;
  5024. }
  5025. } else if( h->slice_type == B_TYPE ) {
  5026. const int mba_xy = h->left_mb_xy[0];
  5027. const int mbb_xy = h->top_mb_xy;
  5028. int ctx = 0;
  5029. int bits;
  5030. if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )
  5031. ctx++;
  5032. if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) )
  5033. ctx++;
  5034. if( !get_cabac( &h->cabac, &h->cabac_state[27+ctx] ) )
  5035. return 0; /* B_Direct_16x16 */
  5036. if( !get_cabac( &h->cabac, &h->cabac_state[27+3] ) ) {
  5037. return 1 + get_cabac( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
  5038. }
  5039. bits = get_cabac( &h->cabac, &h->cabac_state[27+4] ) << 3;
  5040. bits|= get_cabac( &h->cabac, &h->cabac_state[27+5] ) << 2;
  5041. bits|= get_cabac( &h->cabac, &h->cabac_state[27+5] ) << 1;
  5042. bits|= get_cabac( &h->cabac, &h->cabac_state[27+5] );
  5043. if( bits < 8 )
  5044. return bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
  5045. else if( bits == 13 ) {
  5046. return decode_cabac_intra_mb_type(h, 32, 0) + 23;
  5047. } else if( bits == 14 )
  5048. return 11; /* B_L1_L0_8x16 */
  5049. else if( bits == 15 )
  5050. return 22; /* B_8x8 */
  5051. bits= ( bits<<1 ) | get_cabac( &h->cabac, &h->cabac_state[27+5] );
  5052. return bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
  5053. } else {
  5054. /* TODO SI/SP frames? */
  5055. return -1;
  5056. }
  5057. }
  5058. static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
  5059. MpegEncContext * const s = &h->s;
  5060. int mba_xy, mbb_xy;
  5061. int ctx = 0;
  5062. if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
  5063. int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
  5064. mba_xy = mb_xy - 1;
  5065. if( (mb_y&1)
  5066. && h->slice_table[mba_xy] == h->slice_num
  5067. && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
  5068. mba_xy += s->mb_stride;
  5069. if( MB_FIELD ){
  5070. mbb_xy = mb_xy - s->mb_stride;
  5071. if( !(mb_y&1)
  5072. && h->slice_table[mbb_xy] == h->slice_num
  5073. && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
  5074. mbb_xy -= s->mb_stride;
  5075. }else
  5076. mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
  5077. }else{
  5078. int mb_xy = mb_x + mb_y*s->mb_stride;
  5079. mba_xy = mb_xy - 1;
  5080. mbb_xy = mb_xy - s->mb_stride;
  5081. }
  5082. if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
  5083. ctx++;
  5084. if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
  5085. ctx++;
  5086. if( h->slice_type == B_TYPE )
  5087. ctx += 13;
  5088. return get_cabac( &h->cabac, &h->cabac_state[11+ctx] );
  5089. }
  5090. static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
  5091. int mode = 0;
  5092. if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
  5093. return pred_mode;
  5094. mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
  5095. mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
  5096. mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
  5097. if( mode >= pred_mode )
  5098. return mode + 1;
  5099. else
  5100. return mode;
  5101. }
  5102. static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
  5103. const int mba_xy = h->left_mb_xy[0];
  5104. const int mbb_xy = h->top_mb_xy;
  5105. int ctx = 0;
  5106. /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
  5107. if( h->slice_table[mba_xy] == h->slice_num && h->chroma_pred_mode_table[mba_xy] != 0 )
  5108. ctx++;
  5109. if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )
  5110. ctx++;
  5111. if( get_cabac( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
  5112. return 0;
  5113. if( get_cabac( &h->cabac, &h->cabac_state[64+3] ) == 0 )
  5114. return 1;
  5115. if( get_cabac( &h->cabac, &h->cabac_state[64+3] ) == 0 )
  5116. return 2;
  5117. else
  5118. return 3;
  5119. }
  5120. static const uint8_t block_idx_x[16] = {
  5121. 0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
  5122. };
  5123. static const uint8_t block_idx_y[16] = {
  5124. 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
  5125. };
  5126. static const uint8_t block_idx_xy[4][4] = {
  5127. { 0, 2, 8, 10},
  5128. { 1, 3, 9, 11},
  5129. { 4, 6, 12, 14},
  5130. { 5, 7, 13, 15}
  5131. };
  5132. static int decode_cabac_mb_cbp_luma( H264Context *h) {
  5133. int cbp = 0;
  5134. int cbp_b = -1;
  5135. int i8x8;
  5136. if( h->slice_table[h->top_mb_xy] == h->slice_num ) {
  5137. cbp_b = h->top_cbp;
  5138. tprintf("cbp_b = top_cbp = %x\n", cbp_b);
  5139. }
  5140. for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
  5141. int cbp_a = -1;
  5142. int x, y;
  5143. int ctx = 0;
  5144. x = block_idx_x[4*i8x8];
  5145. y = block_idx_y[4*i8x8];
  5146. if( x > 0 )
  5147. cbp_a = cbp;
  5148. else if( h->slice_table[h->left_mb_xy[0]] == h->slice_num ) {
  5149. cbp_a = h->left_cbp;
  5150. tprintf("cbp_a = left_cbp = %x\n", cbp_a);
  5151. }
  5152. if( y > 0 )
  5153. cbp_b = cbp;
  5154. /* No need to test for skip as we put 0 for skip block */
  5155. /* No need to test for IPCM as we put 1 for IPCM block */
  5156. if( cbp_a >= 0 ) {
  5157. int i8x8a = block_idx_xy[(x-1)&0x03][y]/4;
  5158. if( ((cbp_a >> i8x8a)&0x01) == 0 )
  5159. ctx++;
  5160. }
  5161. if( cbp_b >= 0 ) {
  5162. int i8x8b = block_idx_xy[x][(y-1)&0x03]/4;
  5163. if( ((cbp_b >> i8x8b)&0x01) == 0 )
  5164. ctx += 2;
  5165. }
  5166. if( get_cabac( &h->cabac, &h->cabac_state[73 + ctx] ) ) {
  5167. cbp |= 1 << i8x8;
  5168. }
  5169. }
  5170. return cbp;
  5171. }
  5172. static int decode_cabac_mb_cbp_chroma( H264Context *h) {
  5173. int ctx;
  5174. int cbp_a, cbp_b;
  5175. cbp_a = (h->left_cbp>>4)&0x03;
  5176. cbp_b = (h-> top_cbp>>4)&0x03;
  5177. ctx = 0;
  5178. if( cbp_a > 0 ) ctx++;
  5179. if( cbp_b > 0 ) ctx += 2;
  5180. if( get_cabac( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
  5181. return 0;
  5182. ctx = 4;
  5183. if( cbp_a == 2 ) ctx++;
  5184. if( cbp_b == 2 ) ctx += 2;
  5185. return 1 + get_cabac( &h->cabac, &h->cabac_state[77 + ctx] );
  5186. }
  5187. static int decode_cabac_mb_dqp( H264Context *h) {
  5188. MpegEncContext * const s = &h->s;
  5189. int mbn_xy;
  5190. int ctx = 0;
  5191. int val = 0;
  5192. if( s->mb_x > 0 )
  5193. mbn_xy = s->mb_x + s->mb_y*s->mb_stride - 1;
  5194. else
  5195. mbn_xy = s->mb_width - 1 + (s->mb_y-1)*s->mb_stride;
  5196. if( h->last_qscale_diff != 0 )
  5197. ctx++;
  5198. while( get_cabac( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
  5199. if( ctx < 2 )
  5200. ctx = 2;
  5201. else
  5202. ctx = 3;
  5203. val++;
  5204. if(val > 102) //prevent infinite loop
  5205. return INT_MIN;
  5206. }
  5207. if( val&0x01 )
  5208. return (val + 1)/2;
  5209. else
  5210. return -(val + 1)/2;
  5211. }
  5212. static int decode_cabac_p_mb_sub_type( H264Context *h ) {
  5213. if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
  5214. return 0; /* 8x8 */
  5215. if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
  5216. return 1; /* 8x4 */
  5217. if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
  5218. return 2; /* 4x8 */
  5219. return 3; /* 4x4 */
  5220. }
  5221. static int decode_cabac_b_mb_sub_type( H264Context *h ) {
  5222. int type;
  5223. if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
  5224. return 0; /* B_Direct_8x8 */
  5225. if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
  5226. return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
  5227. type = 3;
  5228. if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
  5229. if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
  5230. return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
  5231. type += 4;
  5232. }
  5233. type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
  5234. type += get_cabac( &h->cabac, &h->cabac_state[39] );
  5235. return type;
  5236. }
  5237. static inline int decode_cabac_mb_transform_size( H264Context *h ) {
  5238. return get_cabac( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
  5239. }
  5240. static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
  5241. int refa = h->ref_cache[list][scan8[n] - 1];
  5242. int refb = h->ref_cache[list][scan8[n] - 8];
  5243. int ref = 0;
  5244. int ctx = 0;
  5245. if( h->slice_type == B_TYPE) {
  5246. if( refa > 0 && !h->direct_cache[scan8[n] - 1] )
  5247. ctx++;
  5248. if( refb > 0 && !h->direct_cache[scan8[n] - 8] )
  5249. ctx += 2;
  5250. } else {
  5251. if( refa > 0 )
  5252. ctx++;
  5253. if( refb > 0 )
  5254. ctx += 2;
  5255. }
  5256. while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
  5257. ref++;
  5258. if( ctx < 4 )
  5259. ctx = 4;
  5260. else
  5261. ctx = 5;
  5262. }
  5263. return ref;
  5264. }
  5265. static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
  5266. int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
  5267. abs( h->mvd_cache[list][scan8[n] - 8][l] );
  5268. int ctxbase = (l == 0) ? 40 : 47;
  5269. int ctx, mvd;
  5270. if( amvd < 3 )
  5271. ctx = 0;
  5272. else if( amvd > 32 )
  5273. ctx = 2;
  5274. else
  5275. ctx = 1;
  5276. if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
  5277. return 0;
  5278. mvd= 1;
  5279. ctx= 3;
  5280. while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
  5281. mvd++;
  5282. if( ctx < 6 )
  5283. ctx++;
  5284. }
  5285. if( mvd >= 9 ) {
  5286. int k = 3;
  5287. while( get_cabac_bypass( &h->cabac ) ) {
  5288. mvd += 1 << k;
  5289. k++;
  5290. }
  5291. while( k-- ) {
  5292. if( get_cabac_bypass( &h->cabac ) )
  5293. mvd += 1 << k;
  5294. }
  5295. }
  5296. if( get_cabac_bypass( &h->cabac ) ) return -mvd;
  5297. else return mvd;
  5298. }
  5299. static int inline get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) {
  5300. int nza, nzb;
  5301. int ctx = 0;
  5302. if( cat == 0 ) {
  5303. nza = h->left_cbp&0x100;
  5304. nzb = h-> top_cbp&0x100;
  5305. } else if( cat == 1 || cat == 2 ) {
  5306. nza = h->non_zero_count_cache[scan8[idx] - 1];
  5307. nzb = h->non_zero_count_cache[scan8[idx] - 8];
  5308. } else if( cat == 3 ) {
  5309. nza = (h->left_cbp>>(6+idx))&0x01;
  5310. nzb = (h-> top_cbp>>(6+idx))&0x01;
  5311. } else {
  5312. assert(cat == 4);
  5313. nza = h->non_zero_count_cache[scan8[16+idx] - 1];
  5314. nzb = h->non_zero_count_cache[scan8[16+idx] - 8];
  5315. }
  5316. if( nza > 0 )
  5317. ctx++;
  5318. if( nzb > 0 )
  5319. ctx += 2;
  5320. return ctx + 4 * cat;
  5321. }
  5322. static int decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff) {
  5323. const int mb_xy = h->s.mb_x + h->s.mb_y*h->s.mb_stride;
  5324. static const int significant_coeff_flag_offset[2][6] = {
  5325. { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
  5326. { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
  5327. };
  5328. static const int last_coeff_flag_offset[2][6] = {
  5329. { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
  5330. { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
  5331. };
  5332. static const int coeff_abs_level_m1_offset[6] = {
  5333. 227+0, 227+10, 227+20, 227+30, 227+39, 426
  5334. };
  5335. static const int significant_coeff_flag_offset_8x8[2][63] = {
  5336. { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
  5337. 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
  5338. 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
  5339. 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
  5340. { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
  5341. 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
  5342. 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
  5343. 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
  5344. };
  5345. static const int last_coeff_flag_offset_8x8[63] = {
  5346. 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  5347. 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  5348. 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
  5349. 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
  5350. };
  5351. int index[64];
  5352. int i, last;
  5353. int coeff_count = 0;
  5354. int abslevel1 = 1;
  5355. int abslevelgt1 = 0;
  5356. uint8_t *significant_coeff_ctx_base;
  5357. uint8_t *last_coeff_ctx_base;
  5358. uint8_t *abs_level_m1_ctx_base;
  5359. /* cat: 0-> DC 16x16 n = 0
  5360. * 1-> AC 16x16 n = luma4x4idx
  5361. * 2-> Luma4x4 n = luma4x4idx
  5362. * 3-> DC Chroma n = iCbCr
  5363. * 4-> AC Chroma n = 4 * iCbCr + chroma4x4idx
  5364. * 5-> Luma8x8 n = 4 * luma8x8idx
  5365. */
  5366. /* read coded block flag */
  5367. if( cat != 5 ) {
  5368. if( get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n ) ] ) == 0 ) {
  5369. if( cat == 1 || cat == 2 )
  5370. h->non_zero_count_cache[scan8[n]] = 0;
  5371. else if( cat == 4 )
  5372. h->non_zero_count_cache[scan8[16+n]] = 0;
  5373. return 0;
  5374. }
  5375. }
  5376. significant_coeff_ctx_base = h->cabac_state
  5377. + significant_coeff_flag_offset[MB_FIELD][cat];
  5378. last_coeff_ctx_base = h->cabac_state
  5379. + last_coeff_flag_offset[MB_FIELD][cat];
  5380. abs_level_m1_ctx_base = h->cabac_state
  5381. + coeff_abs_level_m1_offset[cat];
  5382. if( cat == 5 ) {
  5383. #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
  5384. for(last= 0; last < coefs; last++) { \
  5385. uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
  5386. if( get_cabac( &h->cabac, sig_ctx )) { \
  5387. uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
  5388. index[coeff_count++] = last; \
  5389. if( get_cabac( &h->cabac, last_ctx ) ) { \
  5390. last= max_coeff; \
  5391. break; \
  5392. } \
  5393. } \
  5394. }
  5395. const int *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
  5396. DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
  5397. } else {
  5398. DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
  5399. }
  5400. if( last == max_coeff -1 ) {
  5401. index[coeff_count++] = last;
  5402. }
  5403. assert(coeff_count > 0);
  5404. if( cat == 0 )
  5405. h->cbp_table[mb_xy] |= 0x100;
  5406. else if( cat == 1 || cat == 2 )
  5407. h->non_zero_count_cache[scan8[n]] = coeff_count;
  5408. else if( cat == 3 )
  5409. h->cbp_table[mb_xy] |= 0x40 << n;
  5410. else if( cat == 4 )
  5411. h->non_zero_count_cache[scan8[16+n]] = coeff_count;
  5412. else {
  5413. assert( cat == 5 );
  5414. fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
  5415. }
  5416. for( i = coeff_count - 1; i >= 0; i-- ) {
  5417. uint8_t *ctx = (abslevelgt1 != 0 ? 0 : FFMIN( 4, abslevel1 )) + abs_level_m1_ctx_base;
  5418. int j= scantable[index[i]];
  5419. if( get_cabac( &h->cabac, ctx ) == 0 ) {
  5420. if( !qmul ) {
  5421. if( get_cabac_bypass( &h->cabac ) ) block[j] = -1;
  5422. else block[j] = 1;
  5423. }else{
  5424. if( get_cabac_bypass( &h->cabac ) ) block[j] = (-qmul[j] + 32) >> 6;
  5425. else block[j] = ( qmul[j] + 32) >> 6;
  5426. }
  5427. abslevel1++;
  5428. } else {
  5429. int coeff_abs = 2;
  5430. ctx = 5 + FFMIN( 4, abslevelgt1 ) + abs_level_m1_ctx_base;
  5431. while( coeff_abs < 15 && get_cabac( &h->cabac, ctx ) ) {
  5432. coeff_abs++;
  5433. }
  5434. if( coeff_abs >= 15 ) {
  5435. int j = 0;
  5436. while( get_cabac_bypass( &h->cabac ) ) {
  5437. coeff_abs += 1 << j;
  5438. j++;
  5439. }
  5440. while( j-- ) {
  5441. if( get_cabac_bypass( &h->cabac ) )
  5442. coeff_abs += 1 << j ;
  5443. }
  5444. }
  5445. if( !qmul ) {
  5446. if( get_cabac_bypass( &h->cabac ) ) block[j] = -coeff_abs;
  5447. else block[j] = coeff_abs;
  5448. }else{
  5449. if( get_cabac_bypass( &h->cabac ) ) block[j] = (-coeff_abs * qmul[j] + 32) >> 6;
  5450. else block[j] = ( coeff_abs * qmul[j] + 32) >> 6;
  5451. }
  5452. abslevelgt1++;
  5453. }
  5454. }
  5455. return 0;
  5456. }
  5457. static void inline compute_mb_neighbors(H264Context *h)
  5458. {
  5459. MpegEncContext * const s = &h->s;
  5460. const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
  5461. h->top_mb_xy = mb_xy - s->mb_stride;
  5462. h->left_mb_xy[0] = mb_xy - 1;
  5463. if(FRAME_MBAFF){
  5464. const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride;
  5465. const int top_pair_xy = pair_xy - s->mb_stride;
  5466. const int top_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
  5467. const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
  5468. const int curr_mb_frame_flag = !MB_FIELD;
  5469. const int bottom = (s->mb_y & 1);
  5470. if (bottom
  5471. ? !curr_mb_frame_flag // bottom macroblock
  5472. : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock
  5473. ) {
  5474. h->top_mb_xy -= s->mb_stride;
  5475. }
  5476. if (left_mb_frame_flag != curr_mb_frame_flag) {
  5477. h->left_mb_xy[0] = pair_xy - 1;
  5478. }
  5479. }
  5480. return;
  5481. }
  5482. /**
  5483. * decodes a macroblock
  5484. * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
  5485. */
  5486. static int decode_mb_cabac(H264Context *h) {
  5487. MpegEncContext * const s = &h->s;
  5488. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  5489. int mb_type, partition_count, cbp = 0;
  5490. int dct8x8_allowed= h->pps.transform_8x8_mode;
  5491. s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong?)
  5492. tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
  5493. if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) {
  5494. int skip;
  5495. /* a skipped mb needs the aff flag from the following mb */
  5496. if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 )
  5497. predict_field_decoding_flag(h);
  5498. if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
  5499. skip = h->next_mb_skipped;
  5500. else
  5501. skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
  5502. /* read skip flags */
  5503. if( skip ) {
  5504. if( FRAME_MBAFF && (s->mb_y&1)==0 ){
  5505. s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
  5506. h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
  5507. if(h->next_mb_skipped)
  5508. predict_field_decoding_flag(h);
  5509. else
  5510. h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
  5511. }
  5512. decode_mb_skip(h);
  5513. h->cbp_table[mb_xy] = 0;
  5514. h->chroma_pred_mode_table[mb_xy] = 0;
  5515. h->last_qscale_diff = 0;
  5516. return 0;
  5517. }
  5518. }
  5519. if(FRAME_MBAFF){
  5520. if( (s->mb_y&1) == 0 )
  5521. h->mb_mbaff =
  5522. h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
  5523. }else
  5524. h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME);
  5525. h->prev_mb_skipped = 0;
  5526. compute_mb_neighbors(h);
  5527. if( ( mb_type = decode_cabac_mb_type( h ) ) < 0 ) {
  5528. av_log( h->s.avctx, AV_LOG_ERROR, "decode_cabac_mb_type failed\n" );
  5529. return -1;
  5530. }
  5531. if( h->slice_type == B_TYPE ) {
  5532. if( mb_type < 23 ){
  5533. partition_count= b_mb_type_info[mb_type].partition_count;
  5534. mb_type= b_mb_type_info[mb_type].type;
  5535. }else{
  5536. mb_type -= 23;
  5537. goto decode_intra_mb;
  5538. }
  5539. } else if( h->slice_type == P_TYPE ) {
  5540. if( mb_type < 5) {
  5541. partition_count= p_mb_type_info[mb_type].partition_count;
  5542. mb_type= p_mb_type_info[mb_type].type;
  5543. } else {
  5544. mb_type -= 5;
  5545. goto decode_intra_mb;
  5546. }
  5547. } else {
  5548. assert(h->slice_type == I_TYPE);
  5549. decode_intra_mb:
  5550. partition_count = 0;
  5551. cbp= i_mb_type_info[mb_type].cbp;
  5552. h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
  5553. mb_type= i_mb_type_info[mb_type].type;
  5554. }
  5555. if(MB_FIELD)
  5556. mb_type |= MB_TYPE_INTERLACED;
  5557. h->slice_table[ mb_xy ]= h->slice_num;
  5558. if(IS_INTRA_PCM(mb_type)) {
  5559. const uint8_t *ptr;
  5560. unsigned int x, y;
  5561. // We assume these blocks are very rare so we dont optimize it.
  5562. // FIXME The two following lines get the bitstream position in the cabac
  5563. // decode, I think it should be done by a function in cabac.h (or cabac.c).
  5564. ptr= h->cabac.bytestream;
  5565. if (h->cabac.low&0x1) ptr-=CABAC_BITS/8;
  5566. // The pixels are stored in the same order as levels in h->mb array.
  5567. for(y=0; y<16; y++){
  5568. const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3);
  5569. for(x=0; x<16; x++){
  5570. tprintf("LUMA ICPM LEVEL (%3d)\n", *ptr);
  5571. h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= *ptr++;
  5572. }
  5573. }
  5574. for(y=0; y<8; y++){
  5575. const int index= 256 + 4*(y&3) + 32*(y>>2);
  5576. for(x=0; x<8; x++){
  5577. tprintf("CHROMA U ICPM LEVEL (%3d)\n", *ptr);
  5578. h->mb[index + (x&3) + 16*(x>>2)]= *ptr++;
  5579. }
  5580. }
  5581. for(y=0; y<8; y++){
  5582. const int index= 256 + 64 + 4*(y&3) + 32*(y>>2);
  5583. for(x=0; x<8; x++){
  5584. tprintf("CHROMA V ICPM LEVEL (%3d)\n", *ptr);
  5585. h->mb[index + (x&3) + 16*(x>>2)]= *ptr++;
  5586. }
  5587. }
  5588. ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
  5589. // All blocks are present
  5590. h->cbp_table[mb_xy] = 0x1ef;
  5591. h->chroma_pred_mode_table[mb_xy] = 0;
  5592. // In deblocking, the quantizer is 0
  5593. s->current_picture.qscale_table[mb_xy]= 0;
  5594. h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, 0);
  5595. // All coeffs are present
  5596. memset(h->non_zero_count[mb_xy], 16, 16);
  5597. s->current_picture.mb_type[mb_xy]= mb_type;
  5598. return 0;
  5599. }
  5600. if(MB_MBAFF){
  5601. h->ref_count[0] <<= 1;
  5602. h->ref_count[1] <<= 1;
  5603. }
  5604. fill_caches(h, mb_type, 0);
  5605. if( IS_INTRA( mb_type ) ) {
  5606. int i;
  5607. if( IS_INTRA4x4( mb_type ) ) {
  5608. if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) {
  5609. mb_type |= MB_TYPE_8x8DCT;
  5610. for( i = 0; i < 16; i+=4 ) {
  5611. int pred = pred_intra_mode( h, i );
  5612. int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
  5613. fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
  5614. }
  5615. } else {
  5616. for( i = 0; i < 16; i++ ) {
  5617. int pred = pred_intra_mode( h, i );
  5618. h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
  5619. //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
  5620. }
  5621. }
  5622. write_back_intra_pred_mode(h);
  5623. if( check_intra4x4_pred_mode(h) < 0 ) return -1;
  5624. } else {
  5625. h->intra16x16_pred_mode= check_intra_pred_mode( h, h->intra16x16_pred_mode );
  5626. if( h->intra16x16_pred_mode < 0 ) return -1;
  5627. }
  5628. h->chroma_pred_mode_table[mb_xy] =
  5629. h->chroma_pred_mode = decode_cabac_mb_chroma_pre_mode( h );
  5630. h->chroma_pred_mode= check_intra_pred_mode( h, h->chroma_pred_mode );
  5631. if( h->chroma_pred_mode < 0 ) return -1;
  5632. } else if( partition_count == 4 ) {
  5633. int i, j, sub_partition_count[4], list, ref[2][4];
  5634. if( h->slice_type == B_TYPE ) {
  5635. for( i = 0; i < 4; i++ ) {
  5636. h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
  5637. sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
  5638. h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
  5639. }
  5640. if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1])
  5641. || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {
  5642. pred_direct_motion(h, &mb_type);
  5643. if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) {
  5644. for( i = 0; i < 4; i++ )
  5645. if( IS_DIRECT(h->sub_mb_type[i]) )
  5646. fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 );
  5647. }
  5648. }
  5649. } else {
  5650. for( i = 0; i < 4; i++ ) {
  5651. h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
  5652. sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
  5653. h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
  5654. }
  5655. }
  5656. for( list = 0; list < 2; list++ ) {
  5657. if( h->ref_count[list] > 0 ) {
  5658. for( i = 0; i < 4; i++ ) {
  5659. if(IS_DIRECT(h->sub_mb_type[i])) continue;
  5660. if(IS_DIR(h->sub_mb_type[i], 0, list)){
  5661. if( h->ref_count[list] > 1 )
  5662. ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
  5663. else
  5664. ref[list][i] = 0;
  5665. } else {
  5666. ref[list][i] = -1;
  5667. }
  5668. h->ref_cache[list][ scan8[4*i]+1 ]=
  5669. h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
  5670. }
  5671. }
  5672. }
  5673. if(dct8x8_allowed)
  5674. dct8x8_allowed = get_dct8x8_allowed(h);
  5675. for(list=0; list<2; list++){
  5676. for(i=0; i<4; i++){
  5677. if(IS_DIRECT(h->sub_mb_type[i])){
  5678. fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
  5679. continue;
  5680. }
  5681. h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ];
  5682. if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
  5683. const int sub_mb_type= h->sub_mb_type[i];
  5684. const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
  5685. for(j=0; j<sub_partition_count[i]; j++){
  5686. int mpx, mpy;
  5687. int mx, my;
  5688. const int index= 4*i + block_width*j;
  5689. int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
  5690. int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
  5691. pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);
  5692. mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );
  5693. my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );
  5694. tprintf("final mv:%d %d\n", mx, my);
  5695. if(IS_SUB_8X8(sub_mb_type)){
  5696. mv_cache[ 0 ][0]= mv_cache[ 1 ][0]=
  5697. mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
  5698. mv_cache[ 0 ][1]= mv_cache[ 1 ][1]=
  5699. mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
  5700. mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]=
  5701. mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
  5702. mvd_cache[ 0 ][1]= mvd_cache[ 1 ][1]=
  5703. mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
  5704. }else if(IS_SUB_8X4(sub_mb_type)){
  5705. mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx;
  5706. mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my;
  5707. mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]= mx- mpx;
  5708. mvd_cache[ 0 ][1]= mvd_cache[ 1 ][1]= my - mpy;
  5709. }else if(IS_SUB_4X8(sub_mb_type)){
  5710. mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx;
  5711. mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my;
  5712. mvd_cache[ 0 ][0]= mvd_cache[ 8 ][0]= mx - mpx;
  5713. mvd_cache[ 0 ][1]= mvd_cache[ 8 ][1]= my - mpy;
  5714. }else{
  5715. assert(IS_SUB_4X4(sub_mb_type));
  5716. mv_cache[ 0 ][0]= mx;
  5717. mv_cache[ 0 ][1]= my;
  5718. mvd_cache[ 0 ][0]= mx - mpx;
  5719. mvd_cache[ 0 ][1]= my - mpy;
  5720. }
  5721. }
  5722. }else{
  5723. uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
  5724. uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];
  5725. p[0] = p[1] = p[8] = p[9] = 0;
  5726. pd[0]= pd[1]= pd[8]= pd[9]= 0;
  5727. }
  5728. }
  5729. }
  5730. } else if( IS_DIRECT(mb_type) ) {
  5731. pred_direct_motion(h, &mb_type);
  5732. fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
  5733. fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
  5734. dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
  5735. } else {
  5736. int list, mx, my, i, mpx, mpy;
  5737. if(IS_16X16(mb_type)){
  5738. for(list=0; list<2; list++){
  5739. if(IS_DIR(mb_type, 0, list)){
  5740. if(h->ref_count[list] > 0 ){
  5741. const int ref = h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 0 ) : 0;
  5742. fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
  5743. }
  5744. }else
  5745. fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1);
  5746. }
  5747. for(list=0; list<2; list++){
  5748. if(IS_DIR(mb_type, 0, list)){
  5749. pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);
  5750. mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
  5751. my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
  5752. tprintf("final mv:%d %d\n", mx, my);
  5753. fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
  5754. fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
  5755. }else
  5756. fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
  5757. }
  5758. }
  5759. else if(IS_16X8(mb_type)){
  5760. for(list=0; list<2; list++){
  5761. if(h->ref_count[list]>0){
  5762. for(i=0; i<2; i++){
  5763. if(IS_DIR(mb_type, i, list)){
  5764. const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 8*i ) : 0;
  5765. fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
  5766. }else
  5767. fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
  5768. }
  5769. }
  5770. }
  5771. for(list=0; list<2; list++){
  5772. for(i=0; i<2; i++){
  5773. if(IS_DIR(mb_type, i, list)){
  5774. pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);
  5775. mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );
  5776. my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );
  5777. tprintf("final mv:%d %d\n", mx, my);
  5778. fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);
  5779. fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
  5780. }else{
  5781. fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
  5782. fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
  5783. }
  5784. }
  5785. }
  5786. }else{
  5787. assert(IS_8X16(mb_type));
  5788. for(list=0; list<2; list++){
  5789. if(h->ref_count[list]>0){
  5790. for(i=0; i<2; i++){
  5791. if(IS_DIR(mb_type, i, list)){ //FIXME optimize
  5792. const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 4*i ) : 0;
  5793. fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
  5794. }else
  5795. fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
  5796. }
  5797. }
  5798. }
  5799. for(list=0; list<2; list++){
  5800. for(i=0; i<2; i++){
  5801. if(IS_DIR(mb_type, i, list)){
  5802. pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);
  5803. mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );
  5804. my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );
  5805. tprintf("final mv:%d %d\n", mx, my);
  5806. fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
  5807. fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
  5808. }else{
  5809. fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
  5810. fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
  5811. }
  5812. }
  5813. }
  5814. }
  5815. }
  5816. if( IS_INTER( mb_type ) ) {
  5817. h->chroma_pred_mode_table[mb_xy] = 0;
  5818. write_back_motion( h, mb_type );
  5819. }
  5820. if( !IS_INTRA16x16( mb_type ) ) {
  5821. cbp = decode_cabac_mb_cbp_luma( h );
  5822. cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
  5823. }
  5824. h->cbp_table[mb_xy] = cbp;
  5825. if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
  5826. if( decode_cabac_mb_transform_size( h ) )
  5827. mb_type |= MB_TYPE_8x8DCT;
  5828. }
  5829. s->current_picture.mb_type[mb_xy]= mb_type;
  5830. if( cbp || IS_INTRA16x16( mb_type ) ) {
  5831. const uint8_t *scan, *scan8x8, *dc_scan;
  5832. int dqp;
  5833. if(IS_INTERLACED(mb_type)){
  5834. scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
  5835. scan= s->qscale ? h->field_scan : h->field_scan_q0;
  5836. dc_scan= luma_dc_field_scan;
  5837. }else{
  5838. scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
  5839. scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
  5840. dc_scan= luma_dc_zigzag_scan;
  5841. }
  5842. h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h );
  5843. if( dqp == INT_MIN ){
  5844. av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
  5845. return -1;
  5846. }
  5847. s->qscale += dqp;
  5848. if(((unsigned)s->qscale) > 51){
  5849. if(s->qscale<0) s->qscale+= 52;
  5850. else s->qscale-= 52;
  5851. }
  5852. h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale);
  5853. if( IS_INTRA16x16( mb_type ) ) {
  5854. int i;
  5855. //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
  5856. if( decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16) < 0)
  5857. return -1;
  5858. if( cbp&15 ) {
  5859. for( i = 0; i < 16; i++ ) {
  5860. //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
  5861. if( decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 )
  5862. return -1;
  5863. }
  5864. } else {
  5865. fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
  5866. }
  5867. } else {
  5868. int i8x8, i4x4;
  5869. for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
  5870. if( cbp & (1<<i8x8) ) {
  5871. if( IS_8x8DCT(mb_type) ) {
  5872. if( decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
  5873. scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64) < 0 )
  5874. return -1;
  5875. } else
  5876. for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
  5877. const int index = 4*i8x8 + i4x4;
  5878. //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
  5879. 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 )
  5880. return -1;
  5881. }
  5882. } else {
  5883. uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
  5884. nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
  5885. }
  5886. }
  5887. }
  5888. if( cbp&0x30 ){
  5889. int c;
  5890. for( c = 0; c < 2; c++ ) {
  5891. //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
  5892. if( decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4) < 0)
  5893. return -1;
  5894. }
  5895. }
  5896. if( cbp&0x20 ) {
  5897. int c, i;
  5898. for( c = 0; c < 2; c++ ) {
  5899. for( i = 0; i < 4; i++ ) {
  5900. const int index = 16 + 4 * c + i;
  5901. //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
  5902. 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)
  5903. return -1;
  5904. }
  5905. }
  5906. } else {
  5907. uint8_t * const nnz= &h->non_zero_count_cache[0];
  5908. nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
  5909. nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
  5910. }
  5911. } else {
  5912. uint8_t * const nnz= &h->non_zero_count_cache[0];
  5913. fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
  5914. nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
  5915. nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
  5916. h->last_qscale_diff = 0;
  5917. }
  5918. s->current_picture.qscale_table[mb_xy]= s->qscale;
  5919. write_back_non_zero_count(h);
  5920. if(MB_MBAFF){
  5921. h->ref_count[0] >>= 1;
  5922. h->ref_count[1] >>= 1;
  5923. }
  5924. return 0;
  5925. }
  5926. static void filter_mb_edgev( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) {
  5927. int i, d;
  5928. const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 );
  5929. const int alpha = alpha_table[index_a];
  5930. const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )];
  5931. if( bS[0] < 4 ) {
  5932. int8_t tc[4];
  5933. for(i=0; i<4; i++)
  5934. tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] : -1;
  5935. h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc);
  5936. } else {
  5937. /* 16px edge length, because bS=4 is triggered by being at
  5938. * the edge of an intra MB, so all 4 bS are the same */
  5939. for( d = 0; d < 16; d++ ) {
  5940. const int p0 = pix[-1];
  5941. const int p1 = pix[-2];
  5942. const int p2 = pix[-3];
  5943. const int q0 = pix[0];
  5944. const int q1 = pix[1];
  5945. const int q2 = pix[2];
  5946. if( ABS( p0 - q0 ) < alpha &&
  5947. ABS( p1 - p0 ) < beta &&
  5948. ABS( q1 - q0 ) < beta ) {
  5949. if(ABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
  5950. if( ABS( p2 - p0 ) < beta)
  5951. {
  5952. const int p3 = pix[-4];
  5953. /* p0', p1', p2' */
  5954. pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
  5955. pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
  5956. pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
  5957. } else {
  5958. /* p0' */
  5959. pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
  5960. }
  5961. if( ABS( q2 - q0 ) < beta)
  5962. {
  5963. const int q3 = pix[3];
  5964. /* q0', q1', q2' */
  5965. pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
  5966. pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
  5967. pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
  5968. } else {
  5969. /* q0' */
  5970. pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
  5971. }
  5972. }else{
  5973. /* p0', q0' */
  5974. pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
  5975. pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
  5976. }
  5977. 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]);
  5978. }
  5979. pix += stride;
  5980. }
  5981. }
  5982. }
  5983. static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) {
  5984. int i;
  5985. const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 );
  5986. const int alpha = alpha_table[index_a];
  5987. const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )];
  5988. if( bS[0] < 4 ) {
  5989. int8_t tc[4];
  5990. for(i=0; i<4; i++)
  5991. tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] + 1 : 0;
  5992. h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc);
  5993. } else {
  5994. h->s.dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta);
  5995. }
  5996. }
  5997. static void filter_mb_mbaff_edgev( H264Context *h, uint8_t *pix, int stride, int bS[8], int qp[2] ) {
  5998. int i;
  5999. for( i = 0; i < 16; i++, pix += stride) {
  6000. int index_a;
  6001. int alpha;
  6002. int beta;
  6003. int qp_index;
  6004. int bS_index = (i >> 1);
  6005. if (!MB_FIELD) {
  6006. bS_index &= ~1;
  6007. bS_index |= (i & 1);
  6008. }
  6009. if( bS[bS_index] == 0 ) {
  6010. continue;
  6011. }
  6012. qp_index = MB_FIELD ? (i >> 3) : (i & 1);
  6013. index_a = clip( qp[qp_index] + h->slice_alpha_c0_offset, 0, 51 );
  6014. alpha = alpha_table[index_a];
  6015. beta = beta_table[clip( qp[qp_index] + h->slice_beta_offset, 0, 51 )];
  6016. if( bS[bS_index] < 4 ) {
  6017. const int tc0 = tc0_table[index_a][bS[bS_index] - 1];
  6018. const int p0 = pix[-1];
  6019. const int p1 = pix[-2];
  6020. const int p2 = pix[-3];
  6021. const int q0 = pix[0];
  6022. const int q1 = pix[1];
  6023. const int q2 = pix[2];
  6024. if( ABS( p0 - q0 ) < alpha &&
  6025. ABS( p1 - p0 ) < beta &&
  6026. ABS( q1 - q0 ) < beta ) {
  6027. int tc = tc0;
  6028. int i_delta;
  6029. if( ABS( p2 - p0 ) < beta ) {
  6030. pix[-2] = p1 + clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 );
  6031. tc++;
  6032. }
  6033. if( ABS( q2 - q0 ) < beta ) {
  6034. pix[1] = q1 + clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 );
  6035. tc++;
  6036. }
  6037. i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
  6038. pix[-1] = clip_uint8( p0 + i_delta ); /* p0' */
  6039. pix[0] = clip_uint8( q0 - i_delta ); /* q0' */
  6040. 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);
  6041. }
  6042. }else{
  6043. const int p0 = pix[-1];
  6044. const int p1 = pix[-2];
  6045. const int p2 = pix[-3];
  6046. const int q0 = pix[0];
  6047. const int q1 = pix[1];
  6048. const int q2 = pix[2];
  6049. if( ABS( p0 - q0 ) < alpha &&
  6050. ABS( p1 - p0 ) < beta &&
  6051. ABS( q1 - q0 ) < beta ) {
  6052. if(ABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
  6053. if( ABS( p2 - p0 ) < beta)
  6054. {
  6055. const int p3 = pix[-4];
  6056. /* p0', p1', p2' */
  6057. pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
  6058. pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
  6059. pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
  6060. } else {
  6061. /* p0' */
  6062. pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
  6063. }
  6064. if( ABS( q2 - q0 ) < beta)
  6065. {
  6066. const int q3 = pix[3];
  6067. /* q0', q1', q2' */
  6068. pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
  6069. pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
  6070. pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
  6071. } else {
  6072. /* q0' */
  6073. pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
  6074. }
  6075. }else{
  6076. /* p0', q0' */
  6077. pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
  6078. pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
  6079. }
  6080. 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]);
  6081. }
  6082. }
  6083. }
  6084. }
  6085. static void filter_mb_mbaff_edgecv( H264Context *h, uint8_t *pix, int stride, int bS[8], int qp[2] ) {
  6086. int i;
  6087. for( i = 0; i < 8; i++, pix += stride) {
  6088. int index_a;
  6089. int alpha;
  6090. int beta;
  6091. int qp_index;
  6092. int bS_index = i;
  6093. if( bS[bS_index] == 0 ) {
  6094. continue;
  6095. }
  6096. qp_index = MB_FIELD ? (i >> 2) : (i & 1);
  6097. index_a = clip( qp[qp_index] + h->slice_alpha_c0_offset, 0, 51 );
  6098. alpha = alpha_table[index_a];
  6099. beta = beta_table[clip( qp[qp_index] + h->slice_beta_offset, 0, 51 )];
  6100. if( bS[bS_index] < 4 ) {
  6101. const int tc = tc0_table[index_a][bS[bS_index] - 1] + 1;
  6102. const int p0 = pix[-1];
  6103. const int p1 = pix[-2];
  6104. const int q0 = pix[0];
  6105. const int q1 = pix[1];
  6106. if( ABS( p0 - q0 ) < alpha &&
  6107. ABS( p1 - p0 ) < beta &&
  6108. ABS( q1 - q0 ) < beta ) {
  6109. const int i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
  6110. pix[-1] = clip_uint8( p0 + i_delta ); /* p0' */
  6111. pix[0] = clip_uint8( q0 - i_delta ); /* q0' */
  6112. 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);
  6113. }
  6114. }else{
  6115. const int p0 = pix[-1];
  6116. const int p1 = pix[-2];
  6117. const int q0 = pix[0];
  6118. const int q1 = pix[1];
  6119. if( ABS( p0 - q0 ) < alpha &&
  6120. ABS( p1 - p0 ) < beta &&
  6121. ABS( q1 - q0 ) < beta ) {
  6122. pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; /* p0' */
  6123. pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; /* q0' */
  6124. 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]);
  6125. }
  6126. }
  6127. }
  6128. }
  6129. static void filter_mb_edgeh( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) {
  6130. int i, d;
  6131. const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 );
  6132. const int alpha = alpha_table[index_a];
  6133. const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )];
  6134. const int pix_next = stride;
  6135. if( bS[0] < 4 ) {
  6136. int8_t tc[4];
  6137. for(i=0; i<4; i++)
  6138. tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] : -1;
  6139. h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc);
  6140. } else {
  6141. /* 16px edge length, see filter_mb_edgev */
  6142. for( d = 0; d < 16; d++ ) {
  6143. const int p0 = pix[-1*pix_next];
  6144. const int p1 = pix[-2*pix_next];
  6145. const int p2 = pix[-3*pix_next];
  6146. const int q0 = pix[0];
  6147. const int q1 = pix[1*pix_next];
  6148. const int q2 = pix[2*pix_next];
  6149. if( ABS( p0 - q0 ) < alpha &&
  6150. ABS( p1 - p0 ) < beta &&
  6151. ABS( q1 - q0 ) < beta ) {
  6152. const int p3 = pix[-4*pix_next];
  6153. const int q3 = pix[ 3*pix_next];
  6154. if(ABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
  6155. if( ABS( p2 - p0 ) < beta) {
  6156. /* p0', p1', p2' */
  6157. pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
  6158. pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
  6159. pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
  6160. } else {
  6161. /* p0' */
  6162. pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
  6163. }
  6164. if( ABS( q2 - q0 ) < beta) {
  6165. /* q0', q1', q2' */
  6166. pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
  6167. pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
  6168. pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
  6169. } else {
  6170. /* q0' */
  6171. pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
  6172. }
  6173. }else{
  6174. /* p0', q0' */
  6175. pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
  6176. pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
  6177. }
  6178. 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]);
  6179. }
  6180. pix++;
  6181. }
  6182. }
  6183. }
  6184. static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) {
  6185. int i;
  6186. const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 );
  6187. const int alpha = alpha_table[index_a];
  6188. const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )];
  6189. if( bS[0] < 4 ) {
  6190. int8_t tc[4];
  6191. for(i=0; i<4; i++)
  6192. tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] + 1 : 0;
  6193. h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc);
  6194. } else {
  6195. h->s.dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta);
  6196. }
  6197. }
  6198. 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) {
  6199. MpegEncContext * const s = &h->s;
  6200. const int mb_xy= mb_x + mb_y*s->mb_stride;
  6201. const int mb_type = s->current_picture.mb_type[mb_xy];
  6202. const int mvy_limit = IS_INTERLACED(mb_type) ? 2 : 4;
  6203. int first_vertical_edge_done = 0;
  6204. int dir;
  6205. /* FIXME: A given frame may occupy more than one position in
  6206. * the reference list. So ref2frm should be populated with
  6207. * frame numbers, not indices. */
  6208. static const int ref2frm[34] = {-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
  6209. 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
  6210. //for sufficiently low qp, filtering wouldn't do anything
  6211. //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp
  6212. if(!FRAME_MBAFF){
  6213. int qp_thresh = 15 - h->slice_alpha_c0_offset - FFMAX(0, h->pps.chroma_qp_index_offset);
  6214. int qp = s->current_picture.qscale_table[mb_xy];
  6215. if(qp <= qp_thresh
  6216. && (mb_x == 0 || ((qp + s->current_picture.qscale_table[mb_xy-1] + 1)>>1) <= qp_thresh)
  6217. && (mb_y == 0 || ((qp + s->current_picture.qscale_table[h->top_mb_xy] + 1)>>1) <= qp_thresh)){
  6218. return;
  6219. }
  6220. }
  6221. if (FRAME_MBAFF
  6222. // left mb is in picture
  6223. && h->slice_table[mb_xy-1] != 255
  6224. // and current and left pair do not have the same interlaced type
  6225. && (IS_INTERLACED(mb_type) != IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]))
  6226. // and left mb is in the same slice if deblocking_filter == 2
  6227. && (h->deblocking_filter!=2 || h->slice_table[mb_xy-1] == h->slice_table[mb_xy])) {
  6228. /* First vertical edge is different in MBAFF frames
  6229. * There are 8 different bS to compute and 2 different Qp
  6230. */
  6231. const int pair_xy = mb_x + (mb_y&~1)*s->mb_stride;
  6232. const int left_mb_xy[2] = { pair_xy-1, pair_xy-1+s->mb_stride };
  6233. int bS[8];
  6234. int qp[2];
  6235. int chroma_qp[2];
  6236. int mb_qp, mbn0_qp, mbn1_qp;
  6237. int i;
  6238. first_vertical_edge_done = 1;
  6239. if( IS_INTRA(mb_type) )
  6240. bS[0] = bS[1] = bS[2] = bS[3] = bS[4] = bS[5] = bS[6] = bS[7] = 4;
  6241. else {
  6242. for( i = 0; i < 8; i++ ) {
  6243. int mbn_xy = MB_FIELD ? left_mb_xy[i>>2] : left_mb_xy[i&1];
  6244. if( IS_INTRA( s->current_picture.mb_type[mbn_xy] ) )
  6245. bS[i] = 4;
  6246. else if( h->non_zero_count_cache[12+8*(i>>1)] != 0 ||
  6247. /* FIXME: with 8x8dct + cavlc, should check cbp instead of nnz */
  6248. h->non_zero_count[mbn_xy][MB_FIELD ? i&3 : (i>>2)+(mb_y&1)*2] )
  6249. bS[i] = 2;
  6250. else
  6251. bS[i] = 1;
  6252. }
  6253. }
  6254. mb_qp = s->current_picture.qscale_table[mb_xy];
  6255. mbn0_qp = s->current_picture.qscale_table[left_mb_xy[0]];
  6256. mbn1_qp = s->current_picture.qscale_table[left_mb_xy[1]];
  6257. qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1;
  6258. chroma_qp[0] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) +
  6259. get_chroma_qp( h->pps.chroma_qp_index_offset, mbn0_qp ) + 1 ) >> 1;
  6260. qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1;
  6261. chroma_qp[1] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) +
  6262. get_chroma_qp( h->pps.chroma_qp_index_offset, mbn1_qp ) + 1 ) >> 1;
  6263. /* Filter edge */
  6264. 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);
  6265. { int i; for (i = 0; i < 8; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }
  6266. filter_mb_mbaff_edgev ( h, &img_y [0], linesize, bS, qp );
  6267. filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, chroma_qp );
  6268. filter_mb_mbaff_edgecv( h, &img_cr[0], uvlinesize, bS, chroma_qp );
  6269. }
  6270. /* dir : 0 -> vertical edge, 1 -> horizontal edge */
  6271. for( dir = 0; dir < 2; dir++ )
  6272. {
  6273. int edge;
  6274. const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy;
  6275. const int mbm_type = s->current_picture.mb_type[mbm_xy];
  6276. int start = h->slice_table[mbm_xy] == 255 ? 1 : 0;
  6277. const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP))
  6278. == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4;
  6279. // how often to recheck mv-based bS when iterating between edges
  6280. const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 :
  6281. (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0;
  6282. // how often to recheck mv-based bS when iterating along each edge
  6283. const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir));
  6284. if (first_vertical_edge_done) {
  6285. start = 1;
  6286. first_vertical_edge_done = 0;
  6287. }
  6288. if (h->deblocking_filter==2 && h->slice_table[mbm_xy] != h->slice_table[mb_xy])
  6289. start = 1;
  6290. if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0
  6291. && !IS_INTERLACED(mb_type)
  6292. && IS_INTERLACED(mbm_type)
  6293. ) {
  6294. // This is a special case in the norm where the filtering must
  6295. // be done twice (one each of the field) even if we are in a
  6296. // frame macroblock.
  6297. //
  6298. static const int nnz_idx[4] = {4,5,6,3};
  6299. unsigned int tmp_linesize = 2 * linesize;
  6300. unsigned int tmp_uvlinesize = 2 * uvlinesize;
  6301. int mbn_xy = mb_xy - 2 * s->mb_stride;
  6302. int qp, chroma_qp;
  6303. int i, j;
  6304. int bS[4];
  6305. for(j=0; j<2; j++, mbn_xy += s->mb_stride){
  6306. if( IS_INTRA(mb_type) ||
  6307. IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) {
  6308. bS[0] = bS[1] = bS[2] = bS[3] = 3;
  6309. } else {
  6310. const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy];
  6311. for( i = 0; i < 4; i++ ) {
  6312. if( h->non_zero_count_cache[scan8[0]+i] != 0 ||
  6313. mbn_nnz[nnz_idx[i]] != 0 )
  6314. bS[i] = 2;
  6315. else
  6316. bS[i] = 1;
  6317. }
  6318. }
  6319. // Do not use s->qscale as luma quantizer because it has not the same
  6320. // value in IPCM macroblocks.
  6321. qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
  6322. 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);
  6323. { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }
  6324. filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp );
  6325. chroma_qp = ( h->chroma_qp +
  6326. get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
  6327. filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp );
  6328. filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp );
  6329. }
  6330. start = 1;
  6331. }
  6332. /* Calculate bS */
  6333. for( edge = start; edge < edges; edge++ ) {
  6334. /* mbn_xy: neighbor macroblock */
  6335. const int mbn_xy = edge > 0 ? mb_xy : mbm_xy;
  6336. const int mbn_type = s->current_picture.mb_type[mbn_xy];
  6337. int bS[4];
  6338. int qp;
  6339. if( (edge&1) && IS_8x8DCT(mb_type) )
  6340. continue;
  6341. if( IS_INTRA(mb_type) ||
  6342. IS_INTRA(mbn_type) ) {
  6343. int value;
  6344. if (edge == 0) {
  6345. if ( (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type))
  6346. || ((FRAME_MBAFF || (s->picture_structure != PICT_FRAME)) && (dir == 0))
  6347. ) {
  6348. value = 4;
  6349. } else {
  6350. value = 3;
  6351. }
  6352. } else {
  6353. value = 3;
  6354. }
  6355. bS[0] = bS[1] = bS[2] = bS[3] = value;
  6356. } else {
  6357. int i, l;
  6358. int mv_done;
  6359. if( edge & mask_edge ) {
  6360. bS[0] = bS[1] = bS[2] = bS[3] = 0;
  6361. mv_done = 1;
  6362. }
  6363. else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) {
  6364. bS[0] = bS[1] = bS[2] = bS[3] = 1;
  6365. mv_done = 1;
  6366. }
  6367. else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) {
  6368. int b_idx= 8 + 4 + edge * (dir ? 8:1);
  6369. int bn_idx= b_idx - (dir ? 8:1);
  6370. int v = 0;
  6371. for( l = 0; !v && l < 1 + (h->slice_type == B_TYPE); l++ ) {
  6372. v |= ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] ||
  6373. ABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
  6374. ABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit;
  6375. }
  6376. bS[0] = bS[1] = bS[2] = bS[3] = v;
  6377. mv_done = 1;
  6378. }
  6379. else
  6380. mv_done = 0;
  6381. for( i = 0; i < 4; i++ ) {
  6382. int x = dir == 0 ? edge : i;
  6383. int y = dir == 0 ? i : edge;
  6384. int b_idx= 8 + 4 + x + 8*y;
  6385. int bn_idx= b_idx - (dir ? 8:1);
  6386. if( h->non_zero_count_cache[b_idx] != 0 ||
  6387. h->non_zero_count_cache[bn_idx] != 0 ) {
  6388. bS[i] = 2;
  6389. }
  6390. else if(!mv_done)
  6391. {
  6392. bS[i] = 0;
  6393. for( l = 0; l < 1 + (h->slice_type == B_TYPE); l++ ) {
  6394. if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] ||
  6395. ABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
  6396. ABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) {
  6397. bS[i] = 1;
  6398. break;
  6399. }
  6400. }
  6401. }
  6402. }
  6403. if(bS[0]+bS[1]+bS[2]+bS[3] == 0)
  6404. continue;
  6405. }
  6406. /* Filter edge */
  6407. // Do not use s->qscale as luma quantizer because it has not the same
  6408. // value in IPCM macroblocks.
  6409. qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
  6410. //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]);
  6411. tprintf("filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
  6412. { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }
  6413. if( dir == 0 ) {
  6414. filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp );
  6415. if( (edge&1) == 0 ) {
  6416. int chroma_qp = ( h->chroma_qp +
  6417. get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
  6418. filter_mb_edgecv( h, &img_cb[2*edge], uvlinesize, bS, chroma_qp );
  6419. filter_mb_edgecv( h, &img_cr[2*edge], uvlinesize, bS, chroma_qp );
  6420. }
  6421. } else {
  6422. filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp );
  6423. if( (edge&1) == 0 ) {
  6424. int chroma_qp = ( h->chroma_qp +
  6425. get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
  6426. filter_mb_edgech( h, &img_cb[2*edge*uvlinesize], uvlinesize, bS, chroma_qp );
  6427. filter_mb_edgech( h, &img_cr[2*edge*uvlinesize], uvlinesize, bS, chroma_qp );
  6428. }
  6429. }
  6430. }
  6431. }
  6432. }
  6433. static int decode_slice(H264Context *h){
  6434. MpegEncContext * const s = &h->s;
  6435. const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;
  6436. s->mb_skip_run= -1;
  6437. if( h->pps.cabac ) {
  6438. int i;
  6439. /* realign */
  6440. align_get_bits( &s->gb );
  6441. /* init cabac */
  6442. ff_init_cabac_states( &h->cabac, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64 );
  6443. ff_init_cabac_decoder( &h->cabac,
  6444. s->gb.buffer + get_bits_count(&s->gb)/8,
  6445. ( s->gb.size_in_bits - get_bits_count(&s->gb) + 7)/8);
  6446. /* calculate pre-state */
  6447. for( i= 0; i < 460; i++ ) {
  6448. int pre;
  6449. if( h->slice_type == I_TYPE )
  6450. pre = clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 );
  6451. else
  6452. 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 );
  6453. if( pre <= 63 )
  6454. h->cabac_state[i] = 2 * ( 63 - pre ) + 0;
  6455. else
  6456. h->cabac_state[i] = 2 * ( pre - 64 ) + 1;
  6457. }
  6458. for(;;){
  6459. int ret = decode_mb_cabac(h);
  6460. int eos;
  6461. if(ret>=0) hl_decode_mb(h);
  6462. if( ret >= 0 && FRAME_MBAFF ) { //FIXME optimal? or let mb_decode decode 16x32 ?
  6463. s->mb_y++;
  6464. if(ret>=0) ret = decode_mb_cabac(h);
  6465. if(ret>=0) hl_decode_mb(h);
  6466. s->mb_y--;
  6467. }
  6468. eos = get_cabac_terminate( &h->cabac );
  6469. if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 1) {
  6470. 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);
  6471. 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);
  6472. return -1;
  6473. }
  6474. if( ++s->mb_x >= s->mb_width ) {
  6475. s->mb_x = 0;
  6476. ff_draw_horiz_band(s, 16*s->mb_y, 16);
  6477. ++s->mb_y;
  6478. if(FRAME_MBAFF) {
  6479. ++s->mb_y;
  6480. }
  6481. }
  6482. if( eos || s->mb_y >= s->mb_height ) {
  6483. tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
  6484. 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);
  6485. return 0;
  6486. }
  6487. }
  6488. } else {
  6489. for(;;){
  6490. int ret = decode_mb_cavlc(h);
  6491. if(ret>=0) hl_decode_mb(h);
  6492. if(ret>=0 && FRAME_MBAFF){ //FIXME optimal? or let mb_decode decode 16x32 ?
  6493. s->mb_y++;
  6494. ret = decode_mb_cavlc(h);
  6495. if(ret>=0) hl_decode_mb(h);
  6496. s->mb_y--;
  6497. }
  6498. if(ret<0){
  6499. av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
  6500. 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);
  6501. return -1;
  6502. }
  6503. if(++s->mb_x >= s->mb_width){
  6504. s->mb_x=0;
  6505. ff_draw_horiz_band(s, 16*s->mb_y, 16);
  6506. ++s->mb_y;
  6507. if(FRAME_MBAFF) {
  6508. ++s->mb_y;
  6509. }
  6510. if(s->mb_y >= s->mb_height){
  6511. tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
  6512. if(get_bits_count(&s->gb) == s->gb.size_in_bits ) {
  6513. 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);
  6514. return 0;
  6515. }else{
  6516. 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);
  6517. return -1;
  6518. }
  6519. }
  6520. }
  6521. if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){
  6522. tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
  6523. if(get_bits_count(&s->gb) == s->gb.size_in_bits ){
  6524. 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);
  6525. return 0;
  6526. }else{
  6527. 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);
  6528. return -1;
  6529. }
  6530. }
  6531. }
  6532. }
  6533. #if 0
  6534. for(;s->mb_y < s->mb_height; s->mb_y++){
  6535. for(;s->mb_x < s->mb_width; s->mb_x++){
  6536. int ret= decode_mb(h);
  6537. hl_decode_mb(h);
  6538. if(ret<0){
  6539. av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
  6540. 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);
  6541. return -1;
  6542. }
  6543. if(++s->mb_x >= s->mb_width){
  6544. s->mb_x=0;
  6545. if(++s->mb_y >= s->mb_height){
  6546. if(get_bits_count(s->gb) == s->gb.size_in_bits){
  6547. 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);
  6548. return 0;
  6549. }else{
  6550. 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);
  6551. return -1;
  6552. }
  6553. }
  6554. }
  6555. if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){
  6556. if(get_bits_count(s->gb) == s->gb.size_in_bits){
  6557. 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);
  6558. return 0;
  6559. }else{
  6560. 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);
  6561. return -1;
  6562. }
  6563. }
  6564. }
  6565. s->mb_x=0;
  6566. ff_draw_horiz_band(s, 16*s->mb_y, 16);
  6567. }
  6568. #endif
  6569. return -1; //not reached
  6570. }
  6571. static int decode_unregistered_user_data(H264Context *h, int size){
  6572. MpegEncContext * const s = &h->s;
  6573. uint8_t user_data[16+256];
  6574. int e, build, i;
  6575. if(size<16)
  6576. return -1;
  6577. for(i=0; i<sizeof(user_data)-1 && i<size; i++){
  6578. user_data[i]= get_bits(&s->gb, 8);
  6579. }
  6580. user_data[i]= 0;
  6581. e= sscanf(user_data+16, "x264 - core %d"/*%s - H.264/MPEG-4 AVC codec - Copyleft 2005 - http://www.videolan.org/x264.html*/, &build);
  6582. if(e==1 && build>=0)
  6583. h->x264_build= build;
  6584. if(s->avctx->debug & FF_DEBUG_BUGS)
  6585. av_log(s->avctx, AV_LOG_DEBUG, "user data:\"%s\"\n", user_data+16);
  6586. for(; i<size; i++)
  6587. skip_bits(&s->gb, 8);
  6588. return 0;
  6589. }
  6590. static int decode_sei(H264Context *h){
  6591. MpegEncContext * const s = &h->s;
  6592. while(get_bits_count(&s->gb) + 16 < s->gb.size_in_bits){
  6593. int size, type;
  6594. type=0;
  6595. do{
  6596. type+= show_bits(&s->gb, 8);
  6597. }while(get_bits(&s->gb, 8) == 255);
  6598. size=0;
  6599. do{
  6600. size+= show_bits(&s->gb, 8);
  6601. }while(get_bits(&s->gb, 8) == 255);
  6602. switch(type){
  6603. case 5:
  6604. if(decode_unregistered_user_data(h, size) < 0)
  6605. return -1;
  6606. break;
  6607. default:
  6608. skip_bits(&s->gb, 8*size);
  6609. }
  6610. //FIXME check bits here
  6611. align_get_bits(&s->gb);
  6612. }
  6613. return 0;
  6614. }
  6615. static inline void decode_hrd_parameters(H264Context *h, SPS *sps){
  6616. MpegEncContext * const s = &h->s;
  6617. int cpb_count, i;
  6618. cpb_count = get_ue_golomb(&s->gb) + 1;
  6619. get_bits(&s->gb, 4); /* bit_rate_scale */
  6620. get_bits(&s->gb, 4); /* cpb_size_scale */
  6621. for(i=0; i<cpb_count; i++){
  6622. get_ue_golomb(&s->gb); /* bit_rate_value_minus1 */
  6623. get_ue_golomb(&s->gb); /* cpb_size_value_minus1 */
  6624. get_bits1(&s->gb); /* cbr_flag */
  6625. }
  6626. get_bits(&s->gb, 5); /* initial_cpb_removal_delay_length_minus1 */
  6627. get_bits(&s->gb, 5); /* cpb_removal_delay_length_minus1 */
  6628. get_bits(&s->gb, 5); /* dpb_output_delay_length_minus1 */
  6629. get_bits(&s->gb, 5); /* time_offset_length */
  6630. }
  6631. static inline int decode_vui_parameters(H264Context *h, SPS *sps){
  6632. MpegEncContext * const s = &h->s;
  6633. int aspect_ratio_info_present_flag, aspect_ratio_idc;
  6634. int nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag;
  6635. aspect_ratio_info_present_flag= get_bits1(&s->gb);
  6636. if( aspect_ratio_info_present_flag ) {
  6637. aspect_ratio_idc= get_bits(&s->gb, 8);
  6638. if( aspect_ratio_idc == EXTENDED_SAR ) {
  6639. sps->sar.num= get_bits(&s->gb, 16);
  6640. sps->sar.den= get_bits(&s->gb, 16);
  6641. }else if(aspect_ratio_idc < 14){
  6642. sps->sar= pixel_aspect[aspect_ratio_idc];
  6643. }else{
  6644. av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
  6645. return -1;
  6646. }
  6647. }else{
  6648. sps->sar.num=
  6649. sps->sar.den= 0;
  6650. }
  6651. // s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
  6652. if(get_bits1(&s->gb)){ /* overscan_info_present_flag */
  6653. get_bits1(&s->gb); /* overscan_appropriate_flag */
  6654. }
  6655. if(get_bits1(&s->gb)){ /* video_signal_type_present_flag */
  6656. get_bits(&s->gb, 3); /* video_format */
  6657. get_bits1(&s->gb); /* video_full_range_flag */
  6658. if(get_bits1(&s->gb)){ /* colour_description_present_flag */
  6659. get_bits(&s->gb, 8); /* colour_primaries */
  6660. get_bits(&s->gb, 8); /* transfer_characteristics */
  6661. get_bits(&s->gb, 8); /* matrix_coefficients */
  6662. }
  6663. }
  6664. if(get_bits1(&s->gb)){ /* chroma_location_info_present_flag */
  6665. get_ue_golomb(&s->gb); /* chroma_sample_location_type_top_field */
  6666. get_ue_golomb(&s->gb); /* chroma_sample_location_type_bottom_field */
  6667. }
  6668. sps->timing_info_present_flag = get_bits1(&s->gb);
  6669. if(sps->timing_info_present_flag){
  6670. sps->num_units_in_tick = get_bits_long(&s->gb, 32);
  6671. sps->time_scale = get_bits_long(&s->gb, 32);
  6672. sps->fixed_frame_rate_flag = get_bits1(&s->gb);
  6673. }
  6674. nal_hrd_parameters_present_flag = get_bits1(&s->gb);
  6675. if(nal_hrd_parameters_present_flag)
  6676. decode_hrd_parameters(h, sps);
  6677. vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
  6678. if(vcl_hrd_parameters_present_flag)
  6679. decode_hrd_parameters(h, sps);
  6680. if(nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag)
  6681. get_bits1(&s->gb); /* low_delay_hrd_flag */
  6682. get_bits1(&s->gb); /* pic_struct_present_flag */
  6683. sps->bitstream_restriction_flag = get_bits1(&s->gb);
  6684. if(sps->bitstream_restriction_flag){
  6685. get_bits1(&s->gb); /* motion_vectors_over_pic_boundaries_flag */
  6686. get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
  6687. get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
  6688. get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
  6689. get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
  6690. sps->num_reorder_frames = get_ue_golomb(&s->gb);
  6691. get_ue_golomb(&s->gb); /* max_dec_frame_buffering */
  6692. }
  6693. return 0;
  6694. }
  6695. static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
  6696. const uint8_t *jvt_list, const uint8_t *fallback_list){
  6697. MpegEncContext * const s = &h->s;
  6698. int i, last = 8, next = 8;
  6699. const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8;
  6700. if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
  6701. memcpy(factors, fallback_list, size*sizeof(uint8_t));
  6702. else
  6703. for(i=0;i<size;i++){
  6704. if(next)
  6705. next = (last + get_se_golomb(&s->gb)) & 0xff;
  6706. if(!i && !next){ /* matrix not written, we use the preset one */
  6707. memcpy(factors, jvt_list, size*sizeof(uint8_t));
  6708. break;
  6709. }
  6710. last = factors[scan[i]] = next ? next : last;
  6711. }
  6712. }
  6713. static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
  6714. uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
  6715. MpegEncContext * const s = &h->s;
  6716. int fallback_sps = !is_sps && sps->scaling_matrix_present;
  6717. const uint8_t *fallback[4] = {
  6718. fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
  6719. fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
  6720. fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
  6721. fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1]
  6722. };
  6723. if(get_bits1(&s->gb)){
  6724. sps->scaling_matrix_present |= is_sps;
  6725. decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
  6726. decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
  6727. decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
  6728. decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
  6729. decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
  6730. decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
  6731. if(is_sps || pps->transform_8x8_mode){
  6732. decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y
  6733. decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]); // Inter, Y
  6734. }
  6735. } else if(fallback_sps) {
  6736. memcpy(scaling_matrix4, sps->scaling_matrix4, 6*16*sizeof(uint8_t));
  6737. memcpy(scaling_matrix8, sps->scaling_matrix8, 2*64*sizeof(uint8_t));
  6738. }
  6739. }
  6740. static inline int decode_seq_parameter_set(H264Context *h){
  6741. MpegEncContext * const s = &h->s;
  6742. int profile_idc, level_idc;
  6743. int sps_id, i;
  6744. SPS *sps;
  6745. profile_idc= get_bits(&s->gb, 8);
  6746. get_bits1(&s->gb); //constraint_set0_flag
  6747. get_bits1(&s->gb); //constraint_set1_flag
  6748. get_bits1(&s->gb); //constraint_set2_flag
  6749. get_bits1(&s->gb); //constraint_set3_flag
  6750. get_bits(&s->gb, 4); // reserved
  6751. level_idc= get_bits(&s->gb, 8);
  6752. sps_id= get_ue_golomb(&s->gb);
  6753. sps= &h->sps_buffer[ sps_id ];
  6754. sps->profile_idc= profile_idc;
  6755. sps->level_idc= level_idc;
  6756. if(sps->profile_idc >= 100){ //high profile
  6757. if(get_ue_golomb(&s->gb) == 3) //chroma_format_idc
  6758. get_bits1(&s->gb); //residual_color_transform_flag
  6759. get_ue_golomb(&s->gb); //bit_depth_luma_minus8
  6760. get_ue_golomb(&s->gb); //bit_depth_chroma_minus8
  6761. sps->transform_bypass = get_bits1(&s->gb);
  6762. decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
  6763. }else
  6764. sps->scaling_matrix_present = 0;
  6765. sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
  6766. sps->poc_type= get_ue_golomb(&s->gb);
  6767. if(sps->poc_type == 0){ //FIXME #define
  6768. sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
  6769. } else if(sps->poc_type == 1){//FIXME #define
  6770. sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
  6771. sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
  6772. sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
  6773. sps->poc_cycle_length= get_ue_golomb(&s->gb);
  6774. for(i=0; i<sps->poc_cycle_length; i++)
  6775. sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
  6776. }
  6777. if(sps->poc_type > 2){
  6778. av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
  6779. return -1;
  6780. }
  6781. sps->ref_frame_count= get_ue_golomb(&s->gb);
  6782. if(sps->ref_frame_count > MAX_PICTURE_COUNT-2){
  6783. av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
  6784. }
  6785. sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
  6786. sps->mb_width= get_ue_golomb(&s->gb) + 1;
  6787. sps->mb_height= get_ue_golomb(&s->gb) + 1;
  6788. if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
  6789. avcodec_check_dimensions(NULL, 16*sps->mb_width, 16*sps->mb_height))
  6790. return -1;
  6791. sps->frame_mbs_only_flag= get_bits1(&s->gb);
  6792. if(!sps->frame_mbs_only_flag)
  6793. sps->mb_aff= get_bits1(&s->gb);
  6794. else
  6795. sps->mb_aff= 0;
  6796. sps->direct_8x8_inference_flag= get_bits1(&s->gb);
  6797. #ifndef ALLOW_INTERLACE
  6798. if(sps->mb_aff)
  6799. av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it compilation time\n");
  6800. #endif
  6801. if(!sps->direct_8x8_inference_flag && sps->mb_aff)
  6802. av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + !direct_8x8_inference is not implemented\n");
  6803. sps->crop= get_bits1(&s->gb);
  6804. if(sps->crop){
  6805. sps->crop_left = get_ue_golomb(&s->gb);
  6806. sps->crop_right = get_ue_golomb(&s->gb);
  6807. sps->crop_top = get_ue_golomb(&s->gb);
  6808. sps->crop_bottom= get_ue_golomb(&s->gb);
  6809. if(sps->crop_left || sps->crop_top){
  6810. av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
  6811. }
  6812. }else{
  6813. sps->crop_left =
  6814. sps->crop_right =
  6815. sps->crop_top =
  6816. sps->crop_bottom= 0;
  6817. }
  6818. sps->vui_parameters_present_flag= get_bits1(&s->gb);
  6819. if( sps->vui_parameters_present_flag )
  6820. decode_vui_parameters(h, sps);
  6821. if(s->avctx->debug&FF_DEBUG_PICT_INFO){
  6822. 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",
  6823. sps_id, sps->profile_idc, sps->level_idc,
  6824. sps->poc_type,
  6825. sps->ref_frame_count,
  6826. sps->mb_width, sps->mb_height,
  6827. sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
  6828. sps->direct_8x8_inference_flag ? "8B8" : "",
  6829. sps->crop_left, sps->crop_right,
  6830. sps->crop_top, sps->crop_bottom,
  6831. sps->vui_parameters_present_flag ? "VUI" : ""
  6832. );
  6833. }
  6834. return 0;
  6835. }
  6836. static inline int decode_picture_parameter_set(H264Context *h, int bit_length){
  6837. MpegEncContext * const s = &h->s;
  6838. int pps_id= get_ue_golomb(&s->gb);
  6839. PPS *pps= &h->pps_buffer[pps_id];
  6840. pps->sps_id= get_ue_golomb(&s->gb);
  6841. pps->cabac= get_bits1(&s->gb);
  6842. pps->pic_order_present= get_bits1(&s->gb);
  6843. pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
  6844. if(pps->slice_group_count > 1 ){
  6845. pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
  6846. av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
  6847. switch(pps->mb_slice_group_map_type){
  6848. case 0:
  6849. #if 0
  6850. | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
  6851. | run_length[ i ] |1 |ue(v) |
  6852. #endif
  6853. break;
  6854. case 2:
  6855. #if 0
  6856. | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
  6857. |{ | | |
  6858. | top_left_mb[ i ] |1 |ue(v) |
  6859. | bottom_right_mb[ i ] |1 |ue(v) |
  6860. | } | | |
  6861. #endif
  6862. break;
  6863. case 3:
  6864. case 4:
  6865. case 5:
  6866. #if 0
  6867. | slice_group_change_direction_flag |1 |u(1) |
  6868. | slice_group_change_rate_minus1 |1 |ue(v) |
  6869. #endif
  6870. break;
  6871. case 6:
  6872. #if 0
  6873. | slice_group_id_cnt_minus1 |1 |ue(v) |
  6874. | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
  6875. |) | | |
  6876. | slice_group_id[ i ] |1 |u(v) |
  6877. #endif
  6878. break;
  6879. }
  6880. }
  6881. pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
  6882. pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
  6883. if(pps->ref_count[0] > 32 || pps->ref_count[1] > 32){
  6884. av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
  6885. return -1;
  6886. }
  6887. pps->weighted_pred= get_bits1(&s->gb);
  6888. pps->weighted_bipred_idc= get_bits(&s->gb, 2);
  6889. pps->init_qp= get_se_golomb(&s->gb) + 26;
  6890. pps->init_qs= get_se_golomb(&s->gb) + 26;
  6891. pps->chroma_qp_index_offset= get_se_golomb(&s->gb);
  6892. pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
  6893. pps->constrained_intra_pred= get_bits1(&s->gb);
  6894. pps->redundant_pic_cnt_present = get_bits1(&s->gb);
  6895. pps->transform_8x8_mode= 0;
  6896. h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
  6897. memset(pps->scaling_matrix4, 16, 6*16*sizeof(uint8_t));
  6898. memset(pps->scaling_matrix8, 16, 2*64*sizeof(uint8_t));
  6899. if(get_bits_count(&s->gb) < bit_length){
  6900. pps->transform_8x8_mode= get_bits1(&s->gb);
  6901. decode_scaling_matrices(h, &h->sps_buffer[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
  6902. get_se_golomb(&s->gb); //second_chroma_qp_index_offset
  6903. }
  6904. if(s->avctx->debug&FF_DEBUG_PICT_INFO){
  6905. 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",
  6906. pps_id, pps->sps_id,
  6907. pps->cabac ? "CABAC" : "CAVLC",
  6908. pps->slice_group_count,
  6909. pps->ref_count[0], pps->ref_count[1],
  6910. pps->weighted_pred ? "weighted" : "",
  6911. pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset,
  6912. pps->deblocking_filter_parameters_present ? "LPAR" : "",
  6913. pps->constrained_intra_pred ? "CONSTR" : "",
  6914. pps->redundant_pic_cnt_present ? "REDU" : "",
  6915. pps->transform_8x8_mode ? "8x8DCT" : ""
  6916. );
  6917. }
  6918. return 0;
  6919. }
  6920. /**
  6921. * finds the end of the current frame in the bitstream.
  6922. * @return the position of the first byte of the next frame, or -1
  6923. */
  6924. static int find_frame_end(H264Context *h, const uint8_t *buf, int buf_size){
  6925. int i;
  6926. uint32_t state;
  6927. ParseContext *pc = &(h->s.parse_context);
  6928. //printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]);
  6929. // mb_addr= pc->mb_addr - 1;
  6930. state= pc->state;
  6931. for(i=0; i<=buf_size; i++){
  6932. if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){
  6933. tprintf("find_frame_end new startcode = %08x, frame_start_found = %d, pos = %d\n", state, pc->frame_start_found, i);
  6934. if(pc->frame_start_found){
  6935. // If there isn't one more byte in the buffer
  6936. // the test on first_mb_in_slice cannot be done yet
  6937. // do it at next call.
  6938. if (i >= buf_size) break;
  6939. if (buf[i] & 0x80) {
  6940. // first_mb_in_slice is 0, probably the first nal of a new
  6941. // slice
  6942. tprintf("find_frame_end frame_end_found, state = %08x, pos = %d\n", state, i);
  6943. pc->state=-1;
  6944. pc->frame_start_found= 0;
  6945. return i-4;
  6946. }
  6947. }
  6948. pc->frame_start_found = 1;
  6949. }
  6950. if((state&0xFFFFFF1F) == 0x107 || (state&0xFFFFFF1F) == 0x108 || (state&0xFFFFFF1F) == 0x109){
  6951. if(pc->frame_start_found){
  6952. pc->state=-1;
  6953. pc->frame_start_found= 0;
  6954. return i-4;
  6955. }
  6956. }
  6957. if (i<buf_size)
  6958. state= (state<<8) | buf[i];
  6959. }
  6960. pc->state= state;
  6961. return END_NOT_FOUND;
  6962. }
  6963. static int h264_parse(AVCodecParserContext *s,
  6964. AVCodecContext *avctx,
  6965. uint8_t **poutbuf, int *poutbuf_size,
  6966. const uint8_t *buf, int buf_size)
  6967. {
  6968. H264Context *h = s->priv_data;
  6969. ParseContext *pc = &h->s.parse_context;
  6970. int next;
  6971. next= find_frame_end(h, buf, buf_size);
  6972. if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
  6973. *poutbuf = NULL;
  6974. *poutbuf_size = 0;
  6975. return buf_size;
  6976. }
  6977. *poutbuf = (uint8_t *)buf;
  6978. *poutbuf_size = buf_size;
  6979. return next;
  6980. }
  6981. static int h264_split(AVCodecContext *avctx,
  6982. const uint8_t *buf, int buf_size)
  6983. {
  6984. int i;
  6985. uint32_t state = -1;
  6986. int has_sps= 0;
  6987. for(i=0; i<=buf_size; i++){
  6988. if((state&0xFFFFFF1F) == 0x107)
  6989. has_sps=1;
  6990. /* if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){
  6991. }*/
  6992. if((state&0xFFFFFF00) == 0x100 && (state&0xFFFFFF1F) != 0x107 && (state&0xFFFFFF1F) != 0x108 && (state&0xFFFFFF1F) != 0x109){
  6993. if(has_sps){
  6994. while(i>4 && buf[i-5]==0) i--;
  6995. return i-4;
  6996. }
  6997. }
  6998. if (i<buf_size)
  6999. state= (state<<8) | buf[i];
  7000. }
  7001. return 0;
  7002. }
  7003. static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){
  7004. MpegEncContext * const s = &h->s;
  7005. AVCodecContext * const avctx= s->avctx;
  7006. int buf_index=0;
  7007. #if 0
  7008. int i;
  7009. for(i=0; i<50; i++){
  7010. av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]);
  7011. }
  7012. #endif
  7013. h->slice_num = 0;
  7014. s->current_picture_ptr= NULL;
  7015. for(;;){
  7016. int consumed;
  7017. int dst_length;
  7018. int bit_length;
  7019. uint8_t *ptr;
  7020. int i, nalsize = 0;
  7021. if(h->is_avc) {
  7022. if(buf_index >= buf_size) break;
  7023. nalsize = 0;
  7024. for(i = 0; i < h->nal_length_size; i++)
  7025. nalsize = (nalsize << 8) | buf[buf_index++];
  7026. if(nalsize <= 1){
  7027. if(nalsize == 1){
  7028. buf_index++;
  7029. continue;
  7030. }else{
  7031. av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize);
  7032. break;
  7033. }
  7034. }
  7035. } else {
  7036. // start code prefix search
  7037. for(; buf_index + 3 < buf_size; buf_index++){
  7038. // this should allways succeed in the first iteration
  7039. if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1)
  7040. break;
  7041. }
  7042. if(buf_index+3 >= buf_size) break;
  7043. buf_index+=3;
  7044. }
  7045. ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index);
  7046. while(ptr[dst_length - 1] == 0 && dst_length > 1)
  7047. dst_length--;
  7048. bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1);
  7049. if(s->avctx->debug&FF_DEBUG_STARTCODE){
  7050. 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);
  7051. }
  7052. if (h->is_avc && (nalsize != consumed))
  7053. av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize);
  7054. buf_index += consumed;
  7055. if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME dont discard SEI id
  7056. ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
  7057. continue;
  7058. switch(h->nal_unit_type){
  7059. case NAL_IDR_SLICE:
  7060. idr(h); //FIXME ensure we don't loose some frames if there is reordering
  7061. case NAL_SLICE:
  7062. init_get_bits(&s->gb, ptr, bit_length);
  7063. h->intra_gb_ptr=
  7064. h->inter_gb_ptr= &s->gb;
  7065. s->data_partitioning = 0;
  7066. if(decode_slice_header(h) < 0){
  7067. av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");
  7068. break;
  7069. }
  7070. s->current_picture_ptr->key_frame= (h->nal_unit_type == NAL_IDR_SLICE);
  7071. if(h->redundant_pic_count==0 && s->hurry_up < 5
  7072. && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc)
  7073. && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE)
  7074. && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE)
  7075. && avctx->skip_frame < AVDISCARD_ALL)
  7076. decode_slice(h);
  7077. break;
  7078. case NAL_DPA:
  7079. init_get_bits(&s->gb, ptr, bit_length);
  7080. h->intra_gb_ptr=
  7081. h->inter_gb_ptr= NULL;
  7082. s->data_partitioning = 1;
  7083. if(decode_slice_header(h) < 0){
  7084. av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");
  7085. }
  7086. break;
  7087. case NAL_DPB:
  7088. init_get_bits(&h->intra_gb, ptr, bit_length);
  7089. h->intra_gb_ptr= &h->intra_gb;
  7090. break;
  7091. case NAL_DPC:
  7092. init_get_bits(&h->inter_gb, ptr, bit_length);
  7093. h->inter_gb_ptr= &h->inter_gb;
  7094. if(h->redundant_pic_count==0 && h->intra_gb_ptr && s->data_partitioning
  7095. && s->hurry_up < 5
  7096. && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc)
  7097. && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE)
  7098. && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE)
  7099. && avctx->skip_frame < AVDISCARD_ALL)
  7100. decode_slice(h);
  7101. break;
  7102. case NAL_SEI:
  7103. init_get_bits(&s->gb, ptr, bit_length);
  7104. decode_sei(h);
  7105. break;
  7106. case NAL_SPS:
  7107. init_get_bits(&s->gb, ptr, bit_length);
  7108. decode_seq_parameter_set(h);
  7109. if(s->flags& CODEC_FLAG_LOW_DELAY)
  7110. s->low_delay=1;
  7111. if(avctx->has_b_frames < 2)
  7112. avctx->has_b_frames= !s->low_delay;
  7113. break;
  7114. case NAL_PPS:
  7115. init_get_bits(&s->gb, ptr, bit_length);
  7116. decode_picture_parameter_set(h, bit_length);
  7117. break;
  7118. case NAL_AUD:
  7119. case NAL_END_SEQUENCE:
  7120. case NAL_END_STREAM:
  7121. case NAL_FILLER_DATA:
  7122. case NAL_SPS_EXT:
  7123. case NAL_AUXILIARY_SLICE:
  7124. break;
  7125. default:
  7126. av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type);
  7127. }
  7128. }
  7129. if(!s->current_picture_ptr) return buf_index; //no frame
  7130. s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;
  7131. s->current_picture_ptr->pict_type= s->pict_type;
  7132. h->prev_frame_num_offset= h->frame_num_offset;
  7133. h->prev_frame_num= h->frame_num;
  7134. if(s->current_picture_ptr->reference){
  7135. h->prev_poc_msb= h->poc_msb;
  7136. h->prev_poc_lsb= h->poc_lsb;
  7137. }
  7138. if(s->current_picture_ptr->reference)
  7139. execute_ref_pic_marking(h, h->mmco, h->mmco_index);
  7140. ff_er_frame_end(s);
  7141. MPV_frame_end(s);
  7142. return buf_index;
  7143. }
  7144. /**
  7145. * returns the number of bytes consumed for building the current frame
  7146. */
  7147. static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){
  7148. if(s->flags&CODEC_FLAG_TRUNCATED){
  7149. pos -= s->parse_context.last_index;
  7150. if(pos<0) pos=0; // FIXME remove (unneeded?)
  7151. return pos;
  7152. }else{
  7153. if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
  7154. if(pos+10>buf_size) pos=buf_size; // oops ;)
  7155. return pos;
  7156. }
  7157. }
  7158. static int decode_frame(AVCodecContext *avctx,
  7159. void *data, int *data_size,
  7160. uint8_t *buf, int buf_size)
  7161. {
  7162. H264Context *h = avctx->priv_data;
  7163. MpegEncContext *s = &h->s;
  7164. AVFrame *pict = data;
  7165. int buf_index;
  7166. s->flags= avctx->flags;
  7167. s->flags2= avctx->flags2;
  7168. /* no supplementary picture */
  7169. if (buf_size == 0) {
  7170. return 0;
  7171. }
  7172. if(s->flags&CODEC_FLAG_TRUNCATED){
  7173. int next= find_frame_end(h, buf, buf_size);
  7174. if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 )
  7175. return buf_size;
  7176. //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index);
  7177. }
  7178. if(h->is_avc && !h->got_avcC) {
  7179. int i, cnt, nalsize;
  7180. unsigned char *p = avctx->extradata;
  7181. if(avctx->extradata_size < 7) {
  7182. av_log(avctx, AV_LOG_ERROR, "avcC too short\n");
  7183. return -1;
  7184. }
  7185. if(*p != 1) {
  7186. av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p);
  7187. return -1;
  7188. }
  7189. /* sps and pps in the avcC always have length coded with 2 bytes,
  7190. so put a fake nal_length_size = 2 while parsing them */
  7191. h->nal_length_size = 2;
  7192. // Decode sps from avcC
  7193. cnt = *(p+5) & 0x1f; // Number of sps
  7194. p += 6;
  7195. for (i = 0; i < cnt; i++) {
  7196. nalsize = BE_16(p) + 2;
  7197. if(decode_nal_units(h, p, nalsize) < 0) {
  7198. av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i);
  7199. return -1;
  7200. }
  7201. p += nalsize;
  7202. }
  7203. // Decode pps from avcC
  7204. cnt = *(p++); // Number of pps
  7205. for (i = 0; i < cnt; i++) {
  7206. nalsize = BE_16(p) + 2;
  7207. if(decode_nal_units(h, p, nalsize) != nalsize) {
  7208. av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i);
  7209. return -1;
  7210. }
  7211. p += nalsize;
  7212. }
  7213. // Now store right nal length size, that will be use to parse all other nals
  7214. h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1;
  7215. // Do not reparse avcC
  7216. h->got_avcC = 1;
  7217. }
  7218. if(!h->is_avc && s->avctx->extradata_size && s->picture_number==0){
  7219. if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0)
  7220. return -1;
  7221. }
  7222. buf_index=decode_nal_units(h, buf, buf_size);
  7223. if(buf_index < 0)
  7224. return -1;
  7225. //FIXME do something with unavailable reference frames
  7226. // if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_index, buf_size);
  7227. if(!s->current_picture_ptr){
  7228. av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n");
  7229. return -1;
  7230. }
  7231. {
  7232. Picture *out = s->current_picture_ptr;
  7233. #if 0 //decode order
  7234. *data_size = sizeof(AVFrame);
  7235. #else
  7236. /* Sort B-frames into display order */
  7237. Picture *cur = s->current_picture_ptr;
  7238. Picture *prev = h->delayed_output_pic;
  7239. int i, pics, cross_idr, out_of_order, out_idx;
  7240. if(h->sps.bitstream_restriction_flag
  7241. && s->avctx->has_b_frames < h->sps.num_reorder_frames){
  7242. s->avctx->has_b_frames = h->sps.num_reorder_frames;
  7243. s->low_delay = 0;
  7244. }
  7245. pics = 0;
  7246. while(h->delayed_pic[pics]) pics++;
  7247. h->delayed_pic[pics++] = cur;
  7248. if(cur->reference == 0)
  7249. cur->reference = 1;
  7250. cross_idr = 0;
  7251. for(i=0; h->delayed_pic[i]; i++)
  7252. if(h->delayed_pic[i]->key_frame || h->delayed_pic[i]->poc==0)
  7253. cross_idr = 1;
  7254. out = h->delayed_pic[0];
  7255. out_idx = 0;
  7256. for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame; i++)
  7257. if(h->delayed_pic[i]->poc < out->poc){
  7258. out = h->delayed_pic[i];
  7259. out_idx = i;
  7260. }
  7261. out_of_order = !cross_idr && prev && out->poc < prev->poc;
  7262. if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames)
  7263. { }
  7264. else if(prev && pics <= s->avctx->has_b_frames)
  7265. out = prev;
  7266. else if((out_of_order && pics-1 == s->avctx->has_b_frames && pics < 15)
  7267. || (s->low_delay &&
  7268. ((!cross_idr && prev && out->poc > prev->poc + 2)
  7269. || cur->pict_type == B_TYPE)))
  7270. {
  7271. s->low_delay = 0;
  7272. s->avctx->has_b_frames++;
  7273. out = prev;
  7274. }
  7275. else if(out_of_order)
  7276. out = prev;
  7277. if(out_of_order || pics > s->avctx->has_b_frames){
  7278. for(i=out_idx; h->delayed_pic[i]; i++)
  7279. h->delayed_pic[i] = h->delayed_pic[i+1];
  7280. }
  7281. if(prev == out)
  7282. *data_size = 0;
  7283. else
  7284. *data_size = sizeof(AVFrame);
  7285. if(prev && prev != out && prev->reference == 1)
  7286. prev->reference = 0;
  7287. h->delayed_output_pic = out;
  7288. #endif
  7289. if(out)
  7290. *pict= *(AVFrame*)out;
  7291. else
  7292. av_log(avctx, AV_LOG_DEBUG, "no picture\n");
  7293. }
  7294. assert(pict->data[0] || !*data_size);
  7295. ff_print_debug_info(s, pict);
  7296. //printf("out %d\n", (int)pict->data[0]);
  7297. #if 0 //?
  7298. /* Return the Picture timestamp as the frame number */
  7299. /* we substract 1 because it is added on utils.c */
  7300. avctx->frame_number = s->picture_number - 1;
  7301. #endif
  7302. return get_consumed_bytes(s, buf_index, buf_size);
  7303. }
  7304. #if 0
  7305. static inline void fill_mb_avail(H264Context *h){
  7306. MpegEncContext * const s = &h->s;
  7307. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  7308. if(s->mb_y){
  7309. h->mb_avail[0]= s->mb_x && h->slice_table[mb_xy - s->mb_stride - 1] == h->slice_num;
  7310. h->mb_avail[1]= h->slice_table[mb_xy - s->mb_stride ] == h->slice_num;
  7311. h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num;
  7312. }else{
  7313. h->mb_avail[0]=
  7314. h->mb_avail[1]=
  7315. h->mb_avail[2]= 0;
  7316. }
  7317. h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num;
  7318. h->mb_avail[4]= 1; //FIXME move out
  7319. h->mb_avail[5]= 0; //FIXME move out
  7320. }
  7321. #endif
  7322. #if 0 //selftest
  7323. #define COUNT 8000
  7324. #define SIZE (COUNT*40)
  7325. int main(){
  7326. int i;
  7327. uint8_t temp[SIZE];
  7328. PutBitContext pb;
  7329. GetBitContext gb;
  7330. // int int_temp[10000];
  7331. DSPContext dsp;
  7332. AVCodecContext avctx;
  7333. dsputil_init(&dsp, &avctx);
  7334. init_put_bits(&pb, temp, SIZE);
  7335. printf("testing unsigned exp golomb\n");
  7336. for(i=0; i<COUNT; i++){
  7337. START_TIMER
  7338. set_ue_golomb(&pb, i);
  7339. STOP_TIMER("set_ue_golomb");
  7340. }
  7341. flush_put_bits(&pb);
  7342. init_get_bits(&gb, temp, 8*SIZE);
  7343. for(i=0; i<COUNT; i++){
  7344. int j, s;
  7345. s= show_bits(&gb, 24);
  7346. START_TIMER
  7347. j= get_ue_golomb(&gb);
  7348. if(j != i){
  7349. printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
  7350. // return -1;
  7351. }
  7352. STOP_TIMER("get_ue_golomb");
  7353. }
  7354. init_put_bits(&pb, temp, SIZE);
  7355. printf("testing signed exp golomb\n");
  7356. for(i=0; i<COUNT; i++){
  7357. START_TIMER
  7358. set_se_golomb(&pb, i - COUNT/2);
  7359. STOP_TIMER("set_se_golomb");
  7360. }
  7361. flush_put_bits(&pb);
  7362. init_get_bits(&gb, temp, 8*SIZE);
  7363. for(i=0; i<COUNT; i++){
  7364. int j, s;
  7365. s= show_bits(&gb, 24);
  7366. START_TIMER
  7367. j= get_se_golomb(&gb);
  7368. if(j != i - COUNT/2){
  7369. printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
  7370. // return -1;
  7371. }
  7372. STOP_TIMER("get_se_golomb");
  7373. }
  7374. printf("testing 4x4 (I)DCT\n");
  7375. DCTELEM block[16];
  7376. uint8_t src[16], ref[16];
  7377. uint64_t error= 0, max_error=0;
  7378. for(i=0; i<COUNT; i++){
  7379. int j;
  7380. // printf("%d %d %d\n", r1, r2, (r2-r1)*16);
  7381. for(j=0; j<16; j++){
  7382. ref[j]= random()%255;
  7383. src[j]= random()%255;
  7384. }
  7385. h264_diff_dct_c(block, src, ref, 4);
  7386. //normalize
  7387. for(j=0; j<16; j++){
  7388. // printf("%d ", block[j]);
  7389. block[j]= block[j]*4;
  7390. if(j&1) block[j]= (block[j]*4 + 2)/5;
  7391. if(j&4) block[j]= (block[j]*4 + 2)/5;
  7392. }
  7393. // printf("\n");
  7394. s->dsp.h264_idct_add(ref, block, 4);
  7395. /* for(j=0; j<16; j++){
  7396. printf("%d ", ref[j]);
  7397. }
  7398. printf("\n");*/
  7399. for(j=0; j<16; j++){
  7400. int diff= ABS(src[j] - ref[j]);
  7401. error+= diff*diff;
  7402. max_error= FFMAX(max_error, diff);
  7403. }
  7404. }
  7405. printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error );
  7406. #if 0
  7407. printf("testing quantizer\n");
  7408. for(qp=0; qp<52; qp++){
  7409. for(i=0; i<16; i++)
  7410. src1_block[i]= src2_block[i]= random()%255;
  7411. }
  7412. #endif
  7413. printf("Testing NAL layer\n");
  7414. uint8_t bitstream[COUNT];
  7415. uint8_t nal[COUNT*2];
  7416. H264Context h;
  7417. memset(&h, 0, sizeof(H264Context));
  7418. for(i=0; i<COUNT; i++){
  7419. int zeros= i;
  7420. int nal_length;
  7421. int consumed;
  7422. int out_length;
  7423. uint8_t *out;
  7424. int j;
  7425. for(j=0; j<COUNT; j++){
  7426. bitstream[j]= (random() % 255) + 1;
  7427. }
  7428. for(j=0; j<zeros; j++){
  7429. int pos= random() % COUNT;
  7430. while(bitstream[pos] == 0){
  7431. pos++;
  7432. pos %= COUNT;
  7433. }
  7434. bitstream[pos]=0;
  7435. }
  7436. START_TIMER
  7437. nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2);
  7438. if(nal_length<0){
  7439. printf("encoding failed\n");
  7440. return -1;
  7441. }
  7442. out= decode_nal(&h, nal, &out_length, &consumed, nal_length);
  7443. STOP_TIMER("NAL")
  7444. if(out_length != COUNT){
  7445. printf("incorrect length %d %d\n", out_length, COUNT);
  7446. return -1;
  7447. }
  7448. if(consumed != nal_length){
  7449. printf("incorrect consumed length %d %d\n", nal_length, consumed);
  7450. return -1;
  7451. }
  7452. if(memcmp(bitstream, out, COUNT)){
  7453. printf("missmatch\n");
  7454. return -1;
  7455. }
  7456. }
  7457. printf("Testing RBSP\n");
  7458. return 0;
  7459. }
  7460. #endif
  7461. static int decode_end(AVCodecContext *avctx)
  7462. {
  7463. H264Context *h = avctx->priv_data;
  7464. MpegEncContext *s = &h->s;
  7465. av_freep(&h->rbsp_buffer);
  7466. free_tables(h); //FIXME cleanup init stuff perhaps
  7467. MPV_common_end(s);
  7468. // memset(h, 0, sizeof(H264Context));
  7469. return 0;
  7470. }
  7471. AVCodec h264_decoder = {
  7472. "h264",
  7473. CODEC_TYPE_VIDEO,
  7474. CODEC_ID_H264,
  7475. sizeof(H264Context),
  7476. decode_init,
  7477. NULL,
  7478. decode_end,
  7479. decode_frame,
  7480. /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
  7481. .flush= flush_dpb,
  7482. };
  7483. AVCodecParser h264_parser = {
  7484. { CODEC_ID_H264 },
  7485. sizeof(H264Context),
  7486. NULL,
  7487. h264_parse,
  7488. ff_parse_close,
  7489. h264_split,
  7490. };
  7491. #include "svq3.c"