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.

8091 lines
301KB

  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. /**
  48. * Sequence parameter set
  49. */
  50. typedef struct SPS{
  51. int profile_idc;
  52. int level_idc;
  53. int transform_bypass; ///< qpprime_y_zero_transform_bypass_flag
  54. int log2_max_frame_num; ///< log2_max_frame_num_minus4 + 4
  55. int poc_type; ///< pic_order_cnt_type
  56. int log2_max_poc_lsb; ///< log2_max_pic_order_cnt_lsb_minus4
  57. int delta_pic_order_always_zero_flag;
  58. int offset_for_non_ref_pic;
  59. int offset_for_top_to_bottom_field;
  60. int poc_cycle_length; ///< num_ref_frames_in_pic_order_cnt_cycle
  61. int ref_frame_count; ///< num_ref_frames
  62. int gaps_in_frame_num_allowed_flag;
  63. int mb_width; ///< frame_width_in_mbs_minus1 + 1
  64. int mb_height; ///< frame_height_in_mbs_minus1 + 1
  65. int frame_mbs_only_flag;
  66. int mb_aff; ///<mb_adaptive_frame_field_flag
  67. int direct_8x8_inference_flag;
  68. int crop; ///< frame_cropping_flag
  69. int crop_left; ///< frame_cropping_rect_left_offset
  70. int crop_right; ///< frame_cropping_rect_right_offset
  71. int crop_top; ///< frame_cropping_rect_top_offset
  72. int crop_bottom; ///< frame_cropping_rect_bottom_offset
  73. int vui_parameters_present_flag;
  74. AVRational sar;
  75. int timing_info_present_flag;
  76. uint32_t num_units_in_tick;
  77. uint32_t time_scale;
  78. int fixed_frame_rate_flag;
  79. short offset_for_ref_frame[256]; //FIXME dyn aloc?
  80. int bitstream_restriction_flag;
  81. int num_reorder_frames;
  82. int scaling_matrix_present;
  83. uint8_t scaling_matrix4[6][16];
  84. uint8_t scaling_matrix8[2][64];
  85. }SPS;
  86. /**
  87. * Picture parameter set
  88. */
  89. typedef struct PPS{
  90. int sps_id;
  91. int cabac; ///< entropy_coding_mode_flag
  92. int pic_order_present; ///< pic_order_present_flag
  93. int slice_group_count; ///< num_slice_groups_minus1 + 1
  94. int mb_slice_group_map_type;
  95. int ref_count[2]; ///< num_ref_idx_l0/1_active_minus1 + 1
  96. int weighted_pred; ///< weighted_pred_flag
  97. int weighted_bipred_idc;
  98. int init_qp; ///< pic_init_qp_minus26 + 26
  99. int init_qs; ///< pic_init_qs_minus26 + 26
  100. int chroma_qp_index_offset;
  101. int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag
  102. int constrained_intra_pred; ///< constrained_intra_pred_flag
  103. int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag
  104. int transform_8x8_mode; ///< transform_8x8_mode_flag
  105. uint8_t scaling_matrix4[6][16];
  106. uint8_t scaling_matrix8[2][64];
  107. }PPS;
  108. /**
  109. * Memory management control operation opcode.
  110. */
  111. typedef enum MMCOOpcode{
  112. MMCO_END=0,
  113. MMCO_SHORT2UNUSED,
  114. MMCO_LONG2UNUSED,
  115. MMCO_SHORT2LONG,
  116. MMCO_SET_MAX_LONG,
  117. MMCO_RESET,
  118. MMCO_LONG,
  119. } MMCOOpcode;
  120. /**
  121. * Memory management control operation.
  122. */
  123. typedef struct MMCO{
  124. MMCOOpcode opcode;
  125. int short_frame_num;
  126. int long_index;
  127. } MMCO;
  128. /**
  129. * H264Context
  130. */
  131. typedef struct H264Context{
  132. MpegEncContext s;
  133. int nal_ref_idc;
  134. int nal_unit_type;
  135. #define NAL_SLICE 1
  136. #define NAL_DPA 2
  137. #define NAL_DPB 3
  138. #define NAL_DPC 4
  139. #define NAL_IDR_SLICE 5
  140. #define NAL_SEI 6
  141. #define NAL_SPS 7
  142. #define NAL_PPS 8
  143. #define NAL_AUD 9
  144. #define NAL_END_SEQUENCE 10
  145. #define NAL_END_STREAM 11
  146. #define NAL_FILLER_DATA 12
  147. #define NAL_SPS_EXT 13
  148. #define NAL_AUXILIARY_SLICE 19
  149. uint8_t *rbsp_buffer;
  150. unsigned int rbsp_buffer_size;
  151. /**
  152. * Used to parse AVC variant of h264
  153. */
  154. int is_avc; ///< this flag is != 0 if codec is avc1
  155. int got_avcC; ///< flag used to parse avcC data only once
  156. int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4)
  157. int chroma_qp; //QPc
  158. int prev_mb_skipped; //FIXME remove (IMHO not used)
  159. //prediction stuff
  160. int chroma_pred_mode;
  161. int intra16x16_pred_mode;
  162. int top_mb_xy;
  163. int left_mb_xy[2];
  164. int8_t intra4x4_pred_mode_cache[5*8];
  165. int8_t (*intra4x4_pred_mode)[8];
  166. void (*pred4x4 [9+3])(uint8_t *src, uint8_t *topright, int stride);//FIXME move to dsp?
  167. void (*pred8x8l [9+3])(uint8_t *src, int topleft, int topright, int stride);
  168. void (*pred8x8 [4+3])(uint8_t *src, int stride);
  169. void (*pred16x16[4+3])(uint8_t *src, int stride);
  170. unsigned int topleft_samples_available;
  171. unsigned int top_samples_available;
  172. unsigned int topright_samples_available;
  173. unsigned int left_samples_available;
  174. uint8_t (*top_borders[2])[16+2*8];
  175. uint8_t left_border[2*(17+2*9)];
  176. /**
  177. * non zero coeff count cache.
  178. * is 64 if not available.
  179. */
  180. DECLARE_ALIGNED_8(uint8_t, non_zero_count_cache[6*8]);
  181. uint8_t (*non_zero_count)[16];
  182. /**
  183. * Motion vector cache.
  184. */
  185. DECLARE_ALIGNED_8(int16_t, mv_cache[2][5*8][2]);
  186. DECLARE_ALIGNED_8(int8_t, ref_cache[2][5*8]);
  187. #define LIST_NOT_USED -1 //FIXME rename?
  188. #define PART_NOT_AVAILABLE -2
  189. /**
  190. * is 1 if the specific list MV&references are set to 0,0,-2.
  191. */
  192. int mv_cache_clean[2];
  193. /**
  194. * number of neighbors (top and/or left) that used 8x8 dct
  195. */
  196. int neighbor_transform_size;
  197. /**
  198. * block_offset[ 0..23] for frame macroblocks
  199. * block_offset[24..47] for field macroblocks
  200. */
  201. int block_offset[2*(16+8)];
  202. uint32_t *mb2b_xy; //FIXME are these 4 a good idea?
  203. uint32_t *mb2b8_xy;
  204. int b_stride; //FIXME use s->b4_stride
  205. int b8_stride;
  206. int halfpel_flag;
  207. int thirdpel_flag;
  208. int unknown_svq3_flag;
  209. int next_slice_index;
  210. SPS sps_buffer[MAX_SPS_COUNT];
  211. SPS sps; ///< current sps
  212. PPS pps_buffer[MAX_PPS_COUNT];
  213. /**
  214. * current pps
  215. */
  216. PPS pps; //FIXME move to Picture perhaps? (->no) do we need that?
  217. uint32_t dequant4_buffer[6][52][16];
  218. uint32_t dequant8_buffer[2][52][64];
  219. uint32_t (*dequant4_coeff[6])[16];
  220. uint32_t (*dequant8_coeff[2])[64];
  221. int dequant_coeff_pps; ///< reinit tables when pps changes
  222. int slice_num;
  223. uint8_t *slice_table_base;
  224. uint8_t *slice_table; ///< slice_table_base + mb_stride + 1
  225. int slice_type;
  226. int slice_type_fixed;
  227. //interlacing specific flags
  228. int mb_aff_frame;
  229. int mb_field_decoding_flag;
  230. int sub_mb_type[4];
  231. //POC stuff
  232. int poc_lsb;
  233. int poc_msb;
  234. int delta_poc_bottom;
  235. int delta_poc[2];
  236. int frame_num;
  237. int prev_poc_msb; ///< poc_msb of the last reference pic for POC type 0
  238. int prev_poc_lsb; ///< poc_lsb of the last reference pic for POC type 0
  239. int frame_num_offset; ///< for POC type 2
  240. int prev_frame_num_offset; ///< for POC type 2
  241. int prev_frame_num; ///< frame_num of the last pic for POC type 1/2
  242. /**
  243. * frame_num for frames or 2*frame_num for field pics.
  244. */
  245. int curr_pic_num;
  246. /**
  247. * max_frame_num or 2*max_frame_num for field pics.
  248. */
  249. int max_pic_num;
  250. //Weighted pred stuff
  251. int use_weight;
  252. int use_weight_chroma;
  253. int luma_log2_weight_denom;
  254. int chroma_log2_weight_denom;
  255. int luma_weight[2][16];
  256. int luma_offset[2][16];
  257. int chroma_weight[2][16][2];
  258. int chroma_offset[2][16][2];
  259. int implicit_weight[16][16];
  260. //deblock
  261. int deblocking_filter; ///< disable_deblocking_filter_idc with 1<->0
  262. int slice_alpha_c0_offset;
  263. int slice_beta_offset;
  264. int redundant_pic_count;
  265. int direct_spatial_mv_pred;
  266. int dist_scale_factor[16];
  267. int map_col_to_list0[2][16];
  268. /**
  269. * num_ref_idx_l0/1_active_minus1 + 1
  270. */
  271. int ref_count[2];// FIXME split for AFF
  272. Picture *short_ref[32];
  273. Picture *long_ref[32];
  274. Picture default_ref_list[2][32];
  275. Picture ref_list[2][32]; //FIXME size?
  276. Picture field_ref_list[2][32]; //FIXME size?
  277. Picture *delayed_pic[16]; //FIXME size?
  278. Picture *delayed_output_pic;
  279. /**
  280. * memory management control operations buffer.
  281. */
  282. MMCO mmco[MAX_MMCO_COUNT];
  283. int mmco_index;
  284. int long_ref_count; ///< number of actual long term references
  285. int short_ref_count; ///< number of actual short term references
  286. //data partitioning
  287. GetBitContext intra_gb;
  288. GetBitContext inter_gb;
  289. GetBitContext *intra_gb_ptr;
  290. GetBitContext *inter_gb_ptr;
  291. DECLARE_ALIGNED_8(DCTELEM, mb[16*24]);
  292. /**
  293. * Cabac
  294. */
  295. CABACContext cabac;
  296. uint8_t cabac_state[460];
  297. int cabac_init_idc;
  298. /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */
  299. uint16_t *cbp_table;
  300. int top_cbp;
  301. int left_cbp;
  302. /* chroma_pred_mode for i4x4 or i16x16, else 0 */
  303. uint8_t *chroma_pred_mode_table;
  304. int last_qscale_diff;
  305. int16_t (*mvd_table[2])[2];
  306. DECLARE_ALIGNED_8(int16_t, mvd_cache[2][5*8][2]);
  307. uint8_t *direct_table;
  308. uint8_t direct_cache[5*8];
  309. uint8_t zigzag_scan[16];
  310. uint8_t field_scan[16];
  311. uint8_t zigzag_scan8x8[64];
  312. uint8_t zigzag_scan8x8_cavlc[64];
  313. const uint8_t *zigzag_scan_q0;
  314. const uint8_t *field_scan_q0;
  315. const uint8_t *zigzag_scan8x8_q0;
  316. const uint8_t *zigzag_scan8x8_cavlc_q0;
  317. int x264_build;
  318. }H264Context;
  319. static VLC coeff_token_vlc[4];
  320. static VLC chroma_dc_coeff_token_vlc;
  321. static VLC total_zeros_vlc[15];
  322. static VLC chroma_dc_total_zeros_vlc[3];
  323. static VLC run_vlc[6];
  324. static VLC run7_vlc;
  325. static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp);
  326. static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc);
  327. 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);
  328. static always_inline uint32_t pack16to32(int a, int b){
  329. #ifdef WORDS_BIGENDIAN
  330. return (b&0xFFFF) + (a<<16);
  331. #else
  332. return (a&0xFFFF) + (b<<16);
  333. #endif
  334. }
  335. /**
  336. * fill a rectangle.
  337. * @param h height of the rectangle, should be a constant
  338. * @param w width of the rectangle, should be a constant
  339. * @param size the size of val (1 or 4), should be a constant
  340. */
  341. static always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){
  342. uint8_t *p= (uint8_t*)vp;
  343. assert(size==1 || size==4);
  344. w *= size;
  345. stride *= size;
  346. assert((((long)vp)&(FFMIN(w, STRIDE_ALIGN)-1)) == 0);
  347. assert((stride&(w-1))==0);
  348. //FIXME check what gcc generates for 64 bit on x86 and possibly write a 32 bit ver of it
  349. if(w==2 && h==2){
  350. *(uint16_t*)(p + 0)=
  351. *(uint16_t*)(p + stride)= size==4 ? val : val*0x0101;
  352. }else if(w==2 && h==4){
  353. *(uint16_t*)(p + 0*stride)=
  354. *(uint16_t*)(p + 1*stride)=
  355. *(uint16_t*)(p + 2*stride)=
  356. *(uint16_t*)(p + 3*stride)= size==4 ? val : val*0x0101;
  357. }else if(w==4 && h==1){
  358. *(uint32_t*)(p + 0*stride)= size==4 ? val : val*0x01010101;
  359. }else if(w==4 && h==2){
  360. *(uint32_t*)(p + 0*stride)=
  361. *(uint32_t*)(p + 1*stride)= size==4 ? val : val*0x01010101;
  362. }else if(w==4 && h==4){
  363. *(uint32_t*)(p + 0*stride)=
  364. *(uint32_t*)(p + 1*stride)=
  365. *(uint32_t*)(p + 2*stride)=
  366. *(uint32_t*)(p + 3*stride)= size==4 ? val : val*0x01010101;
  367. }else if(w==8 && h==1){
  368. *(uint32_t*)(p + 0)=
  369. *(uint32_t*)(p + 4)= size==4 ? val : val*0x01010101;
  370. }else if(w==8 && h==2){
  371. *(uint32_t*)(p + 0 + 0*stride)=
  372. *(uint32_t*)(p + 4 + 0*stride)=
  373. *(uint32_t*)(p + 0 + 1*stride)=
  374. *(uint32_t*)(p + 4 + 1*stride)= size==4 ? val : val*0x01010101;
  375. }else if(w==8 && h==4){
  376. *(uint64_t*)(p + 0*stride)=
  377. *(uint64_t*)(p + 1*stride)=
  378. *(uint64_t*)(p + 2*stride)=
  379. *(uint64_t*)(p + 3*stride)= size==4 ? val*0x0100000001ULL : val*0x0101010101010101ULL;
  380. }else if(w==16 && h==2){
  381. *(uint64_t*)(p + 0+0*stride)=
  382. *(uint64_t*)(p + 8+0*stride)=
  383. *(uint64_t*)(p + 0+1*stride)=
  384. *(uint64_t*)(p + 8+1*stride)= size==4 ? val*0x0100000001ULL : val*0x0101010101010101ULL;
  385. }else if(w==16 && h==4){
  386. *(uint64_t*)(p + 0+0*stride)=
  387. *(uint64_t*)(p + 8+0*stride)=
  388. *(uint64_t*)(p + 0+1*stride)=
  389. *(uint64_t*)(p + 8+1*stride)=
  390. *(uint64_t*)(p + 0+2*stride)=
  391. *(uint64_t*)(p + 8+2*stride)=
  392. *(uint64_t*)(p + 0+3*stride)=
  393. *(uint64_t*)(p + 8+3*stride)= size==4 ? val*0x0100000001ULL : val*0x0101010101010101ULL;
  394. }else
  395. assert(0);
  396. }
  397. static void fill_caches(H264Context *h, int mb_type, int for_deblock){
  398. MpegEncContext * const s = &h->s;
  399. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  400. int topleft_xy, top_xy, topright_xy, left_xy[2];
  401. int topleft_type, top_type, topright_type, left_type[2];
  402. int left_block[8];
  403. int i;
  404. //FIXME deblocking can skip fill_caches much of the time with multiple slices too.
  405. // the actual condition is whether we're on the edge of a slice,
  406. // and even then the intra and nnz parts are unnecessary.
  407. if(for_deblock && h->slice_num == 1)
  408. return;
  409. //wow what a mess, why didn't they simplify the interlacing&intra stuff, i can't imagine that these complex rules are worth it
  410. top_xy = mb_xy - s->mb_stride;
  411. topleft_xy = top_xy - 1;
  412. topright_xy= top_xy + 1;
  413. left_xy[1] = left_xy[0] = mb_xy-1;
  414. left_block[0]= 0;
  415. left_block[1]= 1;
  416. left_block[2]= 2;
  417. left_block[3]= 3;
  418. left_block[4]= 7;
  419. left_block[5]= 10;
  420. left_block[6]= 8;
  421. left_block[7]= 11;
  422. if(h->mb_aff_frame){
  423. const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride;
  424. const int top_pair_xy = pair_xy - s->mb_stride;
  425. const int topleft_pair_xy = top_pair_xy - 1;
  426. const int topright_pair_xy = top_pair_xy + 1;
  427. const int topleft_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]);
  428. const int top_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
  429. const int topright_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]);
  430. const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
  431. const int curr_mb_frame_flag = !IS_INTERLACED(mb_type);
  432. const int bottom = (s->mb_y & 1);
  433. 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);
  434. if (bottom
  435. ? !curr_mb_frame_flag // bottom macroblock
  436. : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock
  437. ) {
  438. top_xy -= s->mb_stride;
  439. }
  440. if (bottom
  441. ? !curr_mb_frame_flag // bottom macroblock
  442. : (!curr_mb_frame_flag && !topleft_mb_frame_flag) // top macroblock
  443. ) {
  444. topleft_xy -= s->mb_stride;
  445. }
  446. if (bottom
  447. ? !curr_mb_frame_flag // bottom macroblock
  448. : (!curr_mb_frame_flag && !topright_mb_frame_flag) // top macroblock
  449. ) {
  450. topright_xy -= s->mb_stride;
  451. }
  452. if (left_mb_frame_flag != curr_mb_frame_flag) {
  453. left_xy[1] = left_xy[0] = pair_xy - 1;
  454. if (curr_mb_frame_flag) {
  455. if (bottom) {
  456. left_block[0]= 2;
  457. left_block[1]= 2;
  458. left_block[2]= 3;
  459. left_block[3]= 3;
  460. left_block[4]= 8;
  461. left_block[5]= 11;
  462. left_block[6]= 8;
  463. left_block[7]= 11;
  464. } else {
  465. left_block[0]= 0;
  466. left_block[1]= 0;
  467. left_block[2]= 1;
  468. left_block[3]= 1;
  469. left_block[4]= 7;
  470. left_block[5]= 10;
  471. left_block[6]= 7;
  472. left_block[7]= 10;
  473. }
  474. } else {
  475. left_xy[1] += s->mb_stride;
  476. //left_block[0]= 0;
  477. left_block[1]= 2;
  478. left_block[2]= 0;
  479. left_block[3]= 2;
  480. //left_block[4]= 7;
  481. left_block[5]= 10;
  482. left_block[6]= 7;
  483. left_block[7]= 10;
  484. }
  485. }
  486. }
  487. h->top_mb_xy = top_xy;
  488. h->left_mb_xy[0] = left_xy[0];
  489. h->left_mb_xy[1] = left_xy[1];
  490. if(for_deblock){
  491. topleft_type = h->slice_table[topleft_xy ] < 255 ? s->current_picture.mb_type[topleft_xy] : 0;
  492. top_type = h->slice_table[top_xy ] < 255 ? s->current_picture.mb_type[top_xy] : 0;
  493. topright_type= h->slice_table[topright_xy] < 255 ? s->current_picture.mb_type[topright_xy]: 0;
  494. left_type[0] = h->slice_table[left_xy[0] ] < 255 ? s->current_picture.mb_type[left_xy[0]] : 0;
  495. left_type[1] = h->slice_table[left_xy[1] ] < 255 ? s->current_picture.mb_type[left_xy[1]] : 0;
  496. }else{
  497. topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0;
  498. top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0;
  499. topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0;
  500. left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0;
  501. left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0;
  502. }
  503. if(IS_INTRA(mb_type)){
  504. h->topleft_samples_available=
  505. h->top_samples_available=
  506. h->left_samples_available= 0xFFFF;
  507. h->topright_samples_available= 0xEEEA;
  508. if(!IS_INTRA(top_type) && (top_type==0 || h->pps.constrained_intra_pred)){
  509. h->topleft_samples_available= 0xB3FF;
  510. h->top_samples_available= 0x33FF;
  511. h->topright_samples_available= 0x26EA;
  512. }
  513. for(i=0; i<2; i++){
  514. if(!IS_INTRA(left_type[i]) && (left_type[i]==0 || h->pps.constrained_intra_pred)){
  515. h->topleft_samples_available&= 0xDF5F;
  516. h->left_samples_available&= 0x5F5F;
  517. }
  518. }
  519. if(!IS_INTRA(topleft_type) && (topleft_type==0 || h->pps.constrained_intra_pred))
  520. h->topleft_samples_available&= 0x7FFF;
  521. if(!IS_INTRA(topright_type) && (topright_type==0 || h->pps.constrained_intra_pred))
  522. h->topright_samples_available&= 0xFBFF;
  523. if(IS_INTRA4x4(mb_type)){
  524. if(IS_INTRA4x4(top_type)){
  525. h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4];
  526. h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5];
  527. h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6];
  528. h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3];
  529. }else{
  530. int pred;
  531. if(!top_type || (IS_INTER(top_type) && h->pps.constrained_intra_pred))
  532. pred= -1;
  533. else{
  534. pred= 2;
  535. }
  536. h->intra4x4_pred_mode_cache[4+8*0]=
  537. h->intra4x4_pred_mode_cache[5+8*0]=
  538. h->intra4x4_pred_mode_cache[6+8*0]=
  539. h->intra4x4_pred_mode_cache[7+8*0]= pred;
  540. }
  541. for(i=0; i<2; i++){
  542. if(IS_INTRA4x4(left_type[i])){
  543. h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]];
  544. h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]];
  545. }else{
  546. int pred;
  547. if(!left_type[i] || (IS_INTER(left_type[i]) && h->pps.constrained_intra_pred))
  548. pred= -1;
  549. else{
  550. pred= 2;
  551. }
  552. h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]=
  553. h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred;
  554. }
  555. }
  556. }
  557. }
  558. /*
  559. 0 . T T. T T T T
  560. 1 L . .L . . . .
  561. 2 L . .L . . . .
  562. 3 . T TL . . . .
  563. 4 L . .L . . . .
  564. 5 L . .. . . . .
  565. */
  566. //FIXME constraint_intra_pred & partitioning & nnz (lets hope this is just a typo in the spec)
  567. if(top_type){
  568. h->non_zero_count_cache[4+8*0]= h->non_zero_count[top_xy][4];
  569. h->non_zero_count_cache[5+8*0]= h->non_zero_count[top_xy][5];
  570. h->non_zero_count_cache[6+8*0]= h->non_zero_count[top_xy][6];
  571. h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3];
  572. h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][9];
  573. h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8];
  574. h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][12];
  575. h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11];
  576. }else{
  577. h->non_zero_count_cache[4+8*0]=
  578. h->non_zero_count_cache[5+8*0]=
  579. h->non_zero_count_cache[6+8*0]=
  580. h->non_zero_count_cache[7+8*0]=
  581. h->non_zero_count_cache[1+8*0]=
  582. h->non_zero_count_cache[2+8*0]=
  583. h->non_zero_count_cache[1+8*3]=
  584. h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;
  585. }
  586. for (i=0; i<2; i++) {
  587. if(left_type[i]){
  588. h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[0+2*i]];
  589. h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[1+2*i]];
  590. h->non_zero_count_cache[0+8*1 + 8*i]= h->non_zero_count[left_xy[i]][left_block[4+2*i]];
  591. h->non_zero_count_cache[0+8*4 + 8*i]= h->non_zero_count[left_xy[i]][left_block[5+2*i]];
  592. }else{
  593. h->non_zero_count_cache[3+8*1 + 2*8*i]=
  594. h->non_zero_count_cache[3+8*2 + 2*8*i]=
  595. h->non_zero_count_cache[0+8*1 + 8*i]=
  596. h->non_zero_count_cache[0+8*4 + 8*i]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;
  597. }
  598. }
  599. if( h->pps.cabac ) {
  600. // top_cbp
  601. if(top_type) {
  602. h->top_cbp = h->cbp_table[top_xy];
  603. } else if(IS_INTRA(mb_type)) {
  604. h->top_cbp = 0x1C0;
  605. } else {
  606. h->top_cbp = 0;
  607. }
  608. // left_cbp
  609. if (left_type[0]) {
  610. h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0;
  611. } else if(IS_INTRA(mb_type)) {
  612. h->left_cbp = 0x1C0;
  613. } else {
  614. h->left_cbp = 0;
  615. }
  616. if (left_type[0]) {
  617. h->left_cbp |= ((h->cbp_table[left_xy[0]]>>((left_block[0]&(~1))+1))&0x1) << 1;
  618. }
  619. if (left_type[1]) {
  620. h->left_cbp |= ((h->cbp_table[left_xy[1]]>>((left_block[2]&(~1))+1))&0x1) << 3;
  621. }
  622. }
  623. #if 1
  624. //FIXME direct mb can skip much of this
  625. if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){
  626. int list;
  627. for(list=0; list<1+(h->slice_type==B_TYPE); list++){
  628. if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){
  629. /*if(!h->mv_cache_clean[list]){
  630. memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all?
  631. memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t));
  632. h->mv_cache_clean[list]= 1;
  633. }*/
  634. continue;
  635. }
  636. h->mv_cache_clean[list]= 0;
  637. if(USES_LIST(top_type, list)){
  638. const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
  639. const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride;
  640. *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0];
  641. *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1];
  642. *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2];
  643. *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3];
  644. h->ref_cache[list][scan8[0] + 0 - 1*8]=
  645. h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0];
  646. h->ref_cache[list][scan8[0] + 2 - 1*8]=
  647. h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1];
  648. }else{
  649. *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]=
  650. *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]=
  651. *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]=
  652. *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0;
  653. *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101;
  654. }
  655. //FIXME unify cleanup or sth
  656. if(USES_LIST(left_type[0], list)){
  657. const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
  658. const int b8_xy= h->mb2b8_xy[left_xy[0]] + 1;
  659. *(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]];
  660. *(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]];
  661. h->ref_cache[list][scan8[0] - 1 + 0*8]=
  662. h->ref_cache[list][scan8[0] - 1 + 1*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0]>>1)];
  663. }else{
  664. *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 0*8]=
  665. *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 1*8]= 0;
  666. h->ref_cache[list][scan8[0] - 1 + 0*8]=
  667. h->ref_cache[list][scan8[0] - 1 + 1*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE;
  668. }
  669. if(USES_LIST(left_type[1], list)){
  670. const int b_xy= h->mb2b_xy[left_xy[1]] + 3;
  671. const int b8_xy= h->mb2b8_xy[left_xy[1]] + 1;
  672. *(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]];
  673. *(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]];
  674. h->ref_cache[list][scan8[0] - 1 + 2*8]=
  675. h->ref_cache[list][scan8[0] - 1 + 3*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[2]>>1)];
  676. }else{
  677. *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 2*8]=
  678. *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 3*8]= 0;
  679. h->ref_cache[list][scan8[0] - 1 + 2*8]=
  680. h->ref_cache[list][scan8[0] - 1 + 3*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE;
  681. assert((!left_type[0]) == (!left_type[1]));
  682. }
  683. if(for_deblock || (IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred))
  684. continue;
  685. if(USES_LIST(topleft_type, list)){
  686. const int b_xy = h->mb2b_xy[topleft_xy] + 3 + 3*h->b_stride;
  687. const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + h->b8_stride;
  688. *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];
  689. h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy];
  690. }else{
  691. *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= 0;
  692. h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
  693. }
  694. if(USES_LIST(topright_type, list)){
  695. const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride;
  696. const int b8_xy= h->mb2b8_xy[topright_xy] + h->b8_stride;
  697. *(uint32_t*)h->mv_cache[list][scan8[0] + 4 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];
  698. h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy];
  699. }else{
  700. *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0;
  701. h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
  702. }
  703. h->ref_cache[list][scan8[5 ]+1] =
  704. h->ref_cache[list][scan8[7 ]+1] =
  705. h->ref_cache[list][scan8[13]+1] = //FIXME remove past 3 (init somewhere else)
  706. h->ref_cache[list][scan8[4 ]] =
  707. h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE;
  708. *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]=
  709. *(uint32_t*)h->mv_cache [list][scan8[7 ]+1]=
  710. *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)
  711. *(uint32_t*)h->mv_cache [list][scan8[4 ]]=
  712. *(uint32_t*)h->mv_cache [list][scan8[12]]= 0;
  713. if( h->pps.cabac ) {
  714. /* XXX beurk, Load mvd */
  715. if(USES_LIST(topleft_type, list)){
  716. const int b_xy = h->mb2b_xy[topleft_xy] + 3 + 3*h->b_stride;
  717. *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy];
  718. }else{
  719. *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 - 1*8]= 0;
  720. }
  721. if(USES_LIST(top_type, list)){
  722. const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
  723. *(uint32_t*)h->mvd_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 0];
  724. *(uint32_t*)h->mvd_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 1];
  725. *(uint32_t*)h->mvd_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 2];
  726. *(uint32_t*)h->mvd_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 3];
  727. }else{
  728. *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]=
  729. *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]=
  730. *(uint32_t*)h->mvd_cache [list][scan8[0] + 2 - 1*8]=
  731. *(uint32_t*)h->mvd_cache [list][scan8[0] + 3 - 1*8]= 0;
  732. }
  733. if(USES_LIST(left_type[0], list)){
  734. const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
  735. *(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]];
  736. *(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]];
  737. }else{
  738. *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 0*8]=
  739. *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 1*8]= 0;
  740. }
  741. if(USES_LIST(left_type[1], list)){
  742. const int b_xy= h->mb2b_xy[left_xy[1]] + 3;
  743. *(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]];
  744. *(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]];
  745. }else{
  746. *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 2*8]=
  747. *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 3*8]= 0;
  748. }
  749. *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]=
  750. *(uint32_t*)h->mvd_cache [list][scan8[7 ]+1]=
  751. *(uint32_t*)h->mvd_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)
  752. *(uint32_t*)h->mvd_cache [list][scan8[4 ]]=
  753. *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0;
  754. if(h->slice_type == B_TYPE){
  755. fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1);
  756. if(IS_DIRECT(top_type)){
  757. *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101;
  758. }else if(IS_8X8(top_type)){
  759. int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride;
  760. h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy];
  761. h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1];
  762. }else{
  763. *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0;
  764. }
  765. //FIXME interlacing
  766. if(IS_DIRECT(left_type[0])){
  767. h->direct_cache[scan8[0] - 1 + 0*8]=
  768. h->direct_cache[scan8[0] - 1 + 2*8]= 1;
  769. }else if(IS_8X8(left_type[0])){
  770. int b8_xy = h->mb2b8_xy[left_xy[0]] + 1;
  771. h->direct_cache[scan8[0] - 1 + 0*8]= h->direct_table[b8_xy];
  772. h->direct_cache[scan8[0] - 1 + 2*8]= h->direct_table[b8_xy + h->b8_stride];
  773. }else{
  774. h->direct_cache[scan8[0] - 1 + 0*8]=
  775. h->direct_cache[scan8[0] - 1 + 2*8]= 0;
  776. }
  777. }
  778. }
  779. }
  780. }
  781. #endif
  782. h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]);
  783. }
  784. static inline void write_back_intra_pred_mode(H264Context *h){
  785. MpegEncContext * const s = &h->s;
  786. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  787. h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1];
  788. h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2];
  789. h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3];
  790. h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4];
  791. h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4];
  792. h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4];
  793. h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4];
  794. }
  795. /**
  796. * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
  797. */
  798. static inline int check_intra4x4_pred_mode(H264Context *h){
  799. MpegEncContext * const s = &h->s;
  800. static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};
  801. static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};
  802. int i;
  803. if(!(h->top_samples_available&0x8000)){
  804. for(i=0; i<4; i++){
  805. int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];
  806. if(status<0){
  807. 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);
  808. return -1;
  809. } else if(status){
  810. h->intra4x4_pred_mode_cache[scan8[0] + i]= status;
  811. }
  812. }
  813. }
  814. if(!(h->left_samples_available&0x8000)){
  815. for(i=0; i<4; i++){
  816. int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
  817. if(status<0){
  818. 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);
  819. return -1;
  820. } else if(status){
  821. h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
  822. }
  823. }
  824. }
  825. return 0;
  826. } //FIXME cleanup like next
  827. /**
  828. * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
  829. */
  830. static inline int check_intra_pred_mode(H264Context *h, int mode){
  831. MpegEncContext * const s = &h->s;
  832. static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};
  833. static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};
  834. if(mode < 0 || mode > 6) {
  835. 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);
  836. return -1;
  837. }
  838. if(!(h->top_samples_available&0x8000)){
  839. mode= top[ mode ];
  840. if(mode<0){
  841. 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);
  842. return -1;
  843. }
  844. }
  845. if(!(h->left_samples_available&0x8000)){
  846. mode= left[ mode ];
  847. if(mode<0){
  848. 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);
  849. return -1;
  850. }
  851. }
  852. return mode;
  853. }
  854. /**
  855. * gets the predicted intra4x4 prediction mode.
  856. */
  857. static inline int pred_intra_mode(H264Context *h, int n){
  858. const int index8= scan8[n];
  859. const int left= h->intra4x4_pred_mode_cache[index8 - 1];
  860. const int top = h->intra4x4_pred_mode_cache[index8 - 8];
  861. const int min= FFMIN(left, top);
  862. tprintf("mode:%d %d min:%d\n", left ,top, min);
  863. if(min<0) return DC_PRED;
  864. else return min;
  865. }
  866. static inline void write_back_non_zero_count(H264Context *h){
  867. MpegEncContext * const s = &h->s;
  868. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  869. h->non_zero_count[mb_xy][0]= h->non_zero_count_cache[7+8*1];
  870. h->non_zero_count[mb_xy][1]= h->non_zero_count_cache[7+8*2];
  871. h->non_zero_count[mb_xy][2]= h->non_zero_count_cache[7+8*3];
  872. h->non_zero_count[mb_xy][3]= h->non_zero_count_cache[7+8*4];
  873. h->non_zero_count[mb_xy][4]= h->non_zero_count_cache[4+8*4];
  874. h->non_zero_count[mb_xy][5]= h->non_zero_count_cache[5+8*4];
  875. h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4];
  876. h->non_zero_count[mb_xy][9]= h->non_zero_count_cache[1+8*2];
  877. h->non_zero_count[mb_xy][8]= h->non_zero_count_cache[2+8*2];
  878. h->non_zero_count[mb_xy][7]= h->non_zero_count_cache[2+8*1];
  879. h->non_zero_count[mb_xy][12]=h->non_zero_count_cache[1+8*5];
  880. h->non_zero_count[mb_xy][11]=h->non_zero_count_cache[2+8*5];
  881. h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4];
  882. }
  883. /**
  884. * gets the predicted number of non zero coefficients.
  885. * @param n block index
  886. */
  887. static inline int pred_non_zero_count(H264Context *h, int n){
  888. const int index8= scan8[n];
  889. const int left= h->non_zero_count_cache[index8 - 1];
  890. const int top = h->non_zero_count_cache[index8 - 8];
  891. int i= left + top;
  892. if(i<64) i= (i+1)>>1;
  893. tprintf("pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
  894. return i&31;
  895. }
  896. static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){
  897. const int topright_ref= h->ref_cache[list][ i - 8 + part_width ];
  898. if(topright_ref != PART_NOT_AVAILABLE){
  899. *C= h->mv_cache[list][ i - 8 + part_width ];
  900. return topright_ref;
  901. }else{
  902. tprintf("topright MV not available\n");
  903. *C= h->mv_cache[list][ i - 8 - 1 ];
  904. return h->ref_cache[list][ i - 8 - 1 ];
  905. }
  906. }
  907. /**
  908. * gets the predicted MV.
  909. * @param n the block index
  910. * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
  911. * @param mx the x component of the predicted motion vector
  912. * @param my the y component of the predicted motion vector
  913. */
  914. static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){
  915. const int index8= scan8[n];
  916. const int top_ref= h->ref_cache[list][ index8 - 8 ];
  917. const int left_ref= h->ref_cache[list][ index8 - 1 ];
  918. const int16_t * const A= h->mv_cache[list][ index8 - 1 ];
  919. const int16_t * const B= h->mv_cache[list][ index8 - 8 ];
  920. const int16_t * C;
  921. int diagonal_ref, match_count;
  922. assert(part_width==1 || part_width==2 || part_width==4);
  923. /* mv_cache
  924. B . . A T T T T
  925. U . . L . . , .
  926. U . . L . . . .
  927. U . . L . . , .
  928. . . . L . . . .
  929. */
  930. diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width);
  931. match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref);
  932. tprintf("pred_motion match_count=%d\n", match_count);
  933. if(match_count > 1){ //most common
  934. *mx= mid_pred(A[0], B[0], C[0]);
  935. *my= mid_pred(A[1], B[1], C[1]);
  936. }else if(match_count==1){
  937. if(left_ref==ref){
  938. *mx= A[0];
  939. *my= A[1];
  940. }else if(top_ref==ref){
  941. *mx= B[0];
  942. *my= B[1];
  943. }else{
  944. *mx= C[0];
  945. *my= C[1];
  946. }
  947. }else{
  948. if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){
  949. *mx= A[0];
  950. *my= A[1];
  951. }else{
  952. *mx= mid_pred(A[0], B[0], C[0]);
  953. *my= mid_pred(A[1], B[1], C[1]);
  954. }
  955. }
  956. 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);
  957. }
  958. /**
  959. * gets the directionally predicted 16x8 MV.
  960. * @param n the block index
  961. * @param mx the x component of the predicted motion vector
  962. * @param my the y component of the predicted motion vector
  963. */
  964. static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
  965. if(n==0){
  966. const int top_ref= h->ref_cache[list][ scan8[0] - 8 ];
  967. const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ];
  968. 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);
  969. if(top_ref == ref){
  970. *mx= B[0];
  971. *my= B[1];
  972. return;
  973. }
  974. }else{
  975. const int left_ref= h->ref_cache[list][ scan8[8] - 1 ];
  976. const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ];
  977. 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);
  978. if(left_ref == ref){
  979. *mx= A[0];
  980. *my= A[1];
  981. return;
  982. }
  983. }
  984. //RARE
  985. pred_motion(h, n, 4, list, ref, mx, my);
  986. }
  987. /**
  988. * gets the directionally predicted 8x16 MV.
  989. * @param n the block index
  990. * @param mx the x component of the predicted motion vector
  991. * @param my the y component of the predicted motion vector
  992. */
  993. static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
  994. if(n==0){
  995. const int left_ref= h->ref_cache[list][ scan8[0] - 1 ];
  996. const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ];
  997. 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);
  998. if(left_ref == ref){
  999. *mx= A[0];
  1000. *my= A[1];
  1001. return;
  1002. }
  1003. }else{
  1004. const int16_t * C;
  1005. int diagonal_ref;
  1006. diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2);
  1007. 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);
  1008. if(diagonal_ref == ref){
  1009. *mx= C[0];
  1010. *my= C[1];
  1011. return;
  1012. }
  1013. }
  1014. //RARE
  1015. pred_motion(h, n, 2, list, ref, mx, my);
  1016. }
  1017. static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){
  1018. const int top_ref = h->ref_cache[0][ scan8[0] - 8 ];
  1019. const int left_ref= h->ref_cache[0][ scan8[0] - 1 ];
  1020. tprintf("pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y);
  1021. if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE
  1022. || (top_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0)
  1023. || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){
  1024. *mx = *my = 0;
  1025. return;
  1026. }
  1027. pred_motion(h, 0, 4, 0, 0, mx, my);
  1028. return;
  1029. }
  1030. static inline void direct_dist_scale_factor(H264Context * const h){
  1031. const int poc = h->s.current_picture_ptr->poc;
  1032. const int poc1 = h->ref_list[1][0].poc;
  1033. int i;
  1034. for(i=0; i<h->ref_count[0]; i++){
  1035. int poc0 = h->ref_list[0][i].poc;
  1036. int td = clip(poc1 - poc0, -128, 127);
  1037. if(td == 0 /* FIXME || pic0 is a long-term ref */){
  1038. h->dist_scale_factor[i] = 256;
  1039. }else{
  1040. int tb = clip(poc - poc0, -128, 127);
  1041. int tx = (16384 + (ABS(td) >> 1)) / td;
  1042. h->dist_scale_factor[i] = clip((tb*tx + 32) >> 6, -1024, 1023);
  1043. }
  1044. }
  1045. }
  1046. static inline void direct_ref_list_init(H264Context * const h){
  1047. MpegEncContext * const s = &h->s;
  1048. Picture * const ref1 = &h->ref_list[1][0];
  1049. Picture * const cur = s->current_picture_ptr;
  1050. int list, i, j;
  1051. if(cur->pict_type == I_TYPE)
  1052. cur->ref_count[0] = 0;
  1053. if(cur->pict_type != B_TYPE)
  1054. cur->ref_count[1] = 0;
  1055. for(list=0; list<2; list++){
  1056. cur->ref_count[list] = h->ref_count[list];
  1057. for(j=0; j<h->ref_count[list]; j++)
  1058. cur->ref_poc[list][j] = h->ref_list[list][j].poc;
  1059. }
  1060. if(cur->pict_type != B_TYPE || h->direct_spatial_mv_pred)
  1061. return;
  1062. for(list=0; list<2; list++){
  1063. for(i=0; i<ref1->ref_count[list]; i++){
  1064. const int poc = ref1->ref_poc[list][i];
  1065. h->map_col_to_list0[list][i] = 0; /* bogus; fills in for missing frames */
  1066. for(j=0; j<h->ref_count[list]; j++)
  1067. if(h->ref_list[list][j].poc == poc){
  1068. h->map_col_to_list0[list][i] = j;
  1069. break;
  1070. }
  1071. }
  1072. }
  1073. }
  1074. static inline void pred_direct_motion(H264Context * const h, int *mb_type){
  1075. MpegEncContext * const s = &h->s;
  1076. const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
  1077. const int b8_xy = 2*s->mb_x + 2*s->mb_y*h->b8_stride;
  1078. const int b4_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
  1079. const int mb_type_col = h->ref_list[1][0].mb_type[mb_xy];
  1080. const int16_t (*l1mv0)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[0][b4_xy];
  1081. const int16_t (*l1mv1)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[1][b4_xy];
  1082. const int8_t *l1ref0 = &h->ref_list[1][0].ref_index[0][b8_xy];
  1083. const int8_t *l1ref1 = &h->ref_list[1][0].ref_index[1][b8_xy];
  1084. const int is_b8x8 = IS_8X8(*mb_type);
  1085. int sub_mb_type;
  1086. int i8, i4;
  1087. if(IS_8X8(mb_type_col) && !h->sps.direct_8x8_inference_flag){
  1088. /* FIXME save sub mb types from previous frames (or derive from MVs)
  1089. * so we know exactly what block size to use */
  1090. sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */
  1091. *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1;
  1092. }else if(!is_b8x8 && (IS_16X16(mb_type_col) || IS_INTRA(mb_type_col))){
  1093. sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
  1094. *mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */
  1095. }else{
  1096. sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
  1097. *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1;
  1098. }
  1099. if(!is_b8x8)
  1100. *mb_type |= MB_TYPE_DIRECT2;
  1101. 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);
  1102. if(h->direct_spatial_mv_pred){
  1103. int ref[2];
  1104. int mv[2][2];
  1105. int list;
  1106. /* ref = min(neighbors) */
  1107. for(list=0; list<2; list++){
  1108. int refa = h->ref_cache[list][scan8[0] - 1];
  1109. int refb = h->ref_cache[list][scan8[0] - 8];
  1110. int refc = h->ref_cache[list][scan8[0] - 8 + 4];
  1111. if(refc == -2)
  1112. refc = h->ref_cache[list][scan8[0] - 8 - 1];
  1113. ref[list] = refa;
  1114. if(ref[list] < 0 || (refb < ref[list] && refb >= 0))
  1115. ref[list] = refb;
  1116. if(ref[list] < 0 || (refc < ref[list] && refc >= 0))
  1117. ref[list] = refc;
  1118. if(ref[list] < 0)
  1119. ref[list] = -1;
  1120. }
  1121. if(ref[0] < 0 && ref[1] < 0){
  1122. ref[0] = ref[1] = 0;
  1123. mv[0][0] = mv[0][1] =
  1124. mv[1][0] = mv[1][1] = 0;
  1125. }else{
  1126. for(list=0; list<2; list++){
  1127. if(ref[list] >= 0)
  1128. pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]);
  1129. else
  1130. mv[list][0] = mv[list][1] = 0;
  1131. }
  1132. }
  1133. if(ref[1] < 0){
  1134. *mb_type &= ~MB_TYPE_P0L1;
  1135. sub_mb_type &= ~MB_TYPE_P0L1;
  1136. }else if(ref[0] < 0){
  1137. *mb_type &= ~MB_TYPE_P0L0;
  1138. sub_mb_type &= ~MB_TYPE_P0L0;
  1139. }
  1140. if(IS_16X16(*mb_type)){
  1141. fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);
  1142. fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);
  1143. if(!IS_INTRA(mb_type_col)
  1144. && ( (l1ref0[0] == 0 && ABS(l1mv0[0][0]) <= 1 && ABS(l1mv0[0][1]) <= 1)
  1145. || (l1ref0[0] < 0 && l1ref1[0] == 0 && ABS(l1mv1[0][0]) <= 1 && ABS(l1mv1[0][1]) <= 1
  1146. && (h->x264_build>33 || !h->x264_build)))){
  1147. if(ref[0] > 0)
  1148. fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4);
  1149. else
  1150. fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4);
  1151. if(ref[1] > 0)
  1152. fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4);
  1153. else
  1154. fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, 0, 4);
  1155. }else{
  1156. fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4);
  1157. fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4);
  1158. }
  1159. }else{
  1160. for(i8=0; i8<4; i8++){
  1161. const int x8 = i8&1;
  1162. const int y8 = i8>>1;
  1163. if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
  1164. continue;
  1165. h->sub_mb_type[i8] = sub_mb_type;
  1166. fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4);
  1167. fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mv[1][0],mv[1][1]), 4);
  1168. fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);
  1169. fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);
  1170. /* col_zero_flag */
  1171. if(!IS_INTRA(mb_type_col) && ( l1ref0[x8 + y8*h->b8_stride] == 0
  1172. || (l1ref0[x8 + y8*h->b8_stride] < 0 && l1ref1[x8 + y8*h->b8_stride] == 0
  1173. && (h->x264_build>33 || !h->x264_build)))){
  1174. const int16_t (*l1mv)[2]= l1ref0[x8 + y8*h->b8_stride] == 0 ? l1mv0 : l1mv1;
  1175. if(IS_SUB_8X8(sub_mb_type)){
  1176. const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride];
  1177. if(ABS(mv_col[0]) <= 1 && ABS(mv_col[1]) <= 1){
  1178. if(ref[0] == 0)
  1179. fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
  1180. if(ref[1] == 0)
  1181. fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
  1182. }
  1183. }else
  1184. for(i4=0; i4<4; i4++){
  1185. const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride];
  1186. if(ABS(mv_col[0]) <= 1 && ABS(mv_col[1]) <= 1){
  1187. if(ref[0] == 0)
  1188. *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0;
  1189. if(ref[1] == 0)
  1190. *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0;
  1191. }
  1192. }
  1193. }
  1194. }
  1195. }
  1196. }else{ /* direct temporal mv pred */
  1197. if(IS_16X16(*mb_type)){
  1198. fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1);
  1199. if(IS_INTRA(mb_type_col)){
  1200. fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);
  1201. fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, 0, 4);
  1202. fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, 0, 4);
  1203. }else{
  1204. const int ref0 = l1ref0[0] >= 0 ? h->map_col_to_list0[0][l1ref0[0]]
  1205. : h->map_col_to_list0[1][l1ref1[0]];
  1206. const int dist_scale_factor = h->dist_scale_factor[ref0];
  1207. const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0];
  1208. int mv_l0[2];
  1209. mv_l0[0] = (dist_scale_factor * mv_col[0] + 128) >> 8;
  1210. mv_l0[1] = (dist_scale_factor * mv_col[1] + 128) >> 8;
  1211. fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref0, 1);
  1212. fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0],mv_l0[1]), 4);
  1213. 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);
  1214. }
  1215. }else{
  1216. for(i8=0; i8<4; i8++){
  1217. const int x8 = i8&1;
  1218. const int y8 = i8>>1;
  1219. int ref0, dist_scale_factor;
  1220. const int16_t (*l1mv)[2]= l1mv0;
  1221. if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
  1222. continue;
  1223. h->sub_mb_type[i8] = sub_mb_type;
  1224. if(IS_INTRA(mb_type_col)){
  1225. fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);
  1226. fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);
  1227. fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
  1228. fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
  1229. continue;
  1230. }
  1231. ref0 = l1ref0[x8 + y8*h->b8_stride];
  1232. if(ref0 >= 0)
  1233. ref0 = h->map_col_to_list0[0][ref0];
  1234. else{
  1235. ref0 = h->map_col_to_list0[1][l1ref1[x8 + y8*h->b8_stride]];
  1236. l1mv= l1mv1;
  1237. }
  1238. dist_scale_factor = h->dist_scale_factor[ref0];
  1239. fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);
  1240. fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);
  1241. if(IS_SUB_8X8(sub_mb_type)){
  1242. const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride];
  1243. int mx = (dist_scale_factor * mv_col[0] + 128) >> 8;
  1244. int my = (dist_scale_factor * mv_col[1] + 128) >> 8;
  1245. fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);
  1246. fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4);
  1247. }else
  1248. for(i4=0; i4<4; i4++){
  1249. const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride];
  1250. int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]];
  1251. mv_l0[0] = (dist_scale_factor * mv_col[0] + 128) >> 8;
  1252. mv_l0[1] = (dist_scale_factor * mv_col[1] + 128) >> 8;
  1253. *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] =
  1254. pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]);
  1255. }
  1256. }
  1257. }
  1258. }
  1259. }
  1260. static inline void write_back_motion(H264Context *h, int mb_type){
  1261. MpegEncContext * const s = &h->s;
  1262. const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
  1263. const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride;
  1264. int list;
  1265. if(!USES_LIST(mb_type, 0))
  1266. fill_rectangle(&s->current_picture.ref_index[0][b8_xy], 2, 2, h->b8_stride, (uint8_t)LIST_NOT_USED, 1);
  1267. for(list=0; list<2; list++){
  1268. int y;
  1269. if(!USES_LIST(mb_type, list))
  1270. continue;
  1271. for(y=0; y<4; y++){
  1272. *(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];
  1273. *(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];
  1274. }
  1275. if( h->pps.cabac ) {
  1276. for(y=0; y<4; y++){
  1277. *(uint64_t*)h->mvd_table[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+0 + 8*y];
  1278. *(uint64_t*)h->mvd_table[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+2 + 8*y];
  1279. }
  1280. }
  1281. {
  1282. uint8_t *ref_index = &s->current_picture.ref_index[list][b8_xy];
  1283. ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]];
  1284. ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]];
  1285. ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]];
  1286. ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]];
  1287. }
  1288. }
  1289. if(h->slice_type == B_TYPE && h->pps.cabac){
  1290. if(IS_8X8(mb_type)){
  1291. uint8_t *direct_table = &h->direct_table[b8_xy];
  1292. direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0;
  1293. direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0;
  1294. direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0;
  1295. }
  1296. }
  1297. }
  1298. /**
  1299. * Decodes a network abstraction layer unit.
  1300. * @param consumed is the number of bytes used as input
  1301. * @param length is the length of the array
  1302. * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing?
  1303. * @returns decoded bytes, might be src+1 if no escapes
  1304. */
  1305. static uint8_t *decode_nal(H264Context *h, uint8_t *src, int *dst_length, int *consumed, int length){
  1306. int i, si, di;
  1307. uint8_t *dst;
  1308. // src[0]&0x80; //forbidden bit
  1309. h->nal_ref_idc= src[0]>>5;
  1310. h->nal_unit_type= src[0]&0x1F;
  1311. src++; length--;
  1312. #if 0
  1313. for(i=0; i<length; i++)
  1314. printf("%2X ", src[i]);
  1315. #endif
  1316. for(i=0; i+1<length; i+=2){
  1317. if(src[i]) continue;
  1318. if(i>0 && src[i-1]==0) i--;
  1319. if(i+2<length && src[i+1]==0 && src[i+2]<=3){
  1320. if(src[i+2]!=3){
  1321. /* startcode, so we must be past the end */
  1322. length=i;
  1323. }
  1324. break;
  1325. }
  1326. }
  1327. if(i>=length-1){ //no escaped 0
  1328. *dst_length= length;
  1329. *consumed= length+1; //+1 for the header
  1330. return src;
  1331. }
  1332. h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length);
  1333. dst= h->rbsp_buffer;
  1334. //printf("decoding esc\n");
  1335. si=di=0;
  1336. while(si<length){
  1337. //remove escapes (very rare 1:2^22)
  1338. if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){
  1339. if(src[si+2]==3){ //escape
  1340. dst[di++]= 0;
  1341. dst[di++]= 0;
  1342. si+=3;
  1343. continue;
  1344. }else //next start code
  1345. break;
  1346. }
  1347. dst[di++]= src[si++];
  1348. }
  1349. *dst_length= di;
  1350. *consumed= si + 1;//+1 for the header
  1351. //FIXME store exact number of bits in the getbitcontext (its needed for decoding)
  1352. return dst;
  1353. }
  1354. #if 0
  1355. /**
  1356. * @param src the data which should be escaped
  1357. * @param dst the target buffer, dst+1 == src is allowed as a special case
  1358. * @param length the length of the src data
  1359. * @param dst_length the length of the dst array
  1360. * @returns length of escaped data in bytes or -1 if an error occured
  1361. */
  1362. static int encode_nal(H264Context *h, uint8_t *dst, uint8_t *src, int length, int dst_length){
  1363. int i, escape_count, si, di;
  1364. uint8_t *temp;
  1365. assert(length>=0);
  1366. assert(dst_length>0);
  1367. dst[0]= (h->nal_ref_idc<<5) + h->nal_unit_type;
  1368. if(length==0) return 1;
  1369. escape_count= 0;
  1370. for(i=0; i<length; i+=2){
  1371. if(src[i]) continue;
  1372. if(i>0 && src[i-1]==0)
  1373. i--;
  1374. if(i+2<length && src[i+1]==0 && src[i+2]<=3){
  1375. escape_count++;
  1376. i+=2;
  1377. }
  1378. }
  1379. if(escape_count==0){
  1380. if(dst+1 != src)
  1381. memcpy(dst+1, src, length);
  1382. return length + 1;
  1383. }
  1384. if(length + escape_count + 1> dst_length)
  1385. return -1;
  1386. //this should be damn rare (hopefully)
  1387. h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length + escape_count);
  1388. temp= h->rbsp_buffer;
  1389. //printf("encoding esc\n");
  1390. si= 0;
  1391. di= 0;
  1392. while(si < length){
  1393. if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){
  1394. temp[di++]= 0; si++;
  1395. temp[di++]= 0; si++;
  1396. temp[di++]= 3;
  1397. temp[di++]= src[si++];
  1398. }
  1399. else
  1400. temp[di++]= src[si++];
  1401. }
  1402. memcpy(dst+1, temp, length+escape_count);
  1403. assert(di == length+escape_count);
  1404. return di + 1;
  1405. }
  1406. /**
  1407. * write 1,10,100,1000,... for alignment, yes its exactly inverse to mpeg4
  1408. */
  1409. static void encode_rbsp_trailing(PutBitContext *pb){
  1410. int length;
  1411. put_bits(pb, 1, 1);
  1412. length= (-put_bits_count(pb))&7;
  1413. if(length) put_bits(pb, length, 0);
  1414. }
  1415. #endif
  1416. /**
  1417. * identifies the exact end of the bitstream
  1418. * @return the length of the trailing, or 0 if damaged
  1419. */
  1420. static int decode_rbsp_trailing(uint8_t *src){
  1421. int v= *src;
  1422. int r;
  1423. tprintf("rbsp trailing %X\n", v);
  1424. for(r=1; r<9; r++){
  1425. if(v&1) return r;
  1426. v>>=1;
  1427. }
  1428. return 0;
  1429. }
  1430. /**
  1431. * idct tranforms the 16 dc values and dequantize them.
  1432. * @param qp quantization parameter
  1433. */
  1434. static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
  1435. #define stride 16
  1436. int i;
  1437. int temp[16]; //FIXME check if this is a good idea
  1438. static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};
  1439. static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
  1440. //memset(block, 64, 2*256);
  1441. //return;
  1442. for(i=0; i<4; i++){
  1443. const int offset= y_offset[i];
  1444. const int z0= block[offset+stride*0] + block[offset+stride*4];
  1445. const int z1= block[offset+stride*0] - block[offset+stride*4];
  1446. const int z2= block[offset+stride*1] - block[offset+stride*5];
  1447. const int z3= block[offset+stride*1] + block[offset+stride*5];
  1448. temp[4*i+0]= z0+z3;
  1449. temp[4*i+1]= z1+z2;
  1450. temp[4*i+2]= z1-z2;
  1451. temp[4*i+3]= z0-z3;
  1452. }
  1453. for(i=0; i<4; i++){
  1454. const int offset= x_offset[i];
  1455. const int z0= temp[4*0+i] + temp[4*2+i];
  1456. const int z1= temp[4*0+i] - temp[4*2+i];
  1457. const int z2= temp[4*1+i] - temp[4*3+i];
  1458. const int z3= temp[4*1+i] + temp[4*3+i];
  1459. block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_resdual
  1460. block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8));
  1461. block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8));
  1462. block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8));
  1463. }
  1464. }
  1465. #if 0
  1466. /**
  1467. * dct tranforms the 16 dc values.
  1468. * @param qp quantization parameter ??? FIXME
  1469. */
  1470. static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){
  1471. // const int qmul= dequant_coeff[qp][0];
  1472. int i;
  1473. int temp[16]; //FIXME check if this is a good idea
  1474. static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};
  1475. static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
  1476. for(i=0; i<4; i++){
  1477. const int offset= y_offset[i];
  1478. const int z0= block[offset+stride*0] + block[offset+stride*4];
  1479. const int z1= block[offset+stride*0] - block[offset+stride*4];
  1480. const int z2= block[offset+stride*1] - block[offset+stride*5];
  1481. const int z3= block[offset+stride*1] + block[offset+stride*5];
  1482. temp[4*i+0]= z0+z3;
  1483. temp[4*i+1]= z1+z2;
  1484. temp[4*i+2]= z1-z2;
  1485. temp[4*i+3]= z0-z3;
  1486. }
  1487. for(i=0; i<4; i++){
  1488. const int offset= x_offset[i];
  1489. const int z0= temp[4*0+i] + temp[4*2+i];
  1490. const int z1= temp[4*0+i] - temp[4*2+i];
  1491. const int z2= temp[4*1+i] - temp[4*3+i];
  1492. const int z3= temp[4*1+i] + temp[4*3+i];
  1493. block[stride*0 +offset]= (z0 + z3)>>1;
  1494. block[stride*2 +offset]= (z1 + z2)>>1;
  1495. block[stride*8 +offset]= (z1 - z2)>>1;
  1496. block[stride*10+offset]= (z0 - z3)>>1;
  1497. }
  1498. }
  1499. #endif
  1500. #undef xStride
  1501. #undef stride
  1502. static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
  1503. const int stride= 16*2;
  1504. const int xStride= 16;
  1505. int a,b,c,d,e;
  1506. a= block[stride*0 + xStride*0];
  1507. b= block[stride*0 + xStride*1];
  1508. c= block[stride*1 + xStride*0];
  1509. d= block[stride*1 + xStride*1];
  1510. e= a-b;
  1511. a= a+b;
  1512. b= c-d;
  1513. c= c+d;
  1514. block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7;
  1515. block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7;
  1516. block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7;
  1517. block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7;
  1518. }
  1519. #if 0
  1520. static void chroma_dc_dct_c(DCTELEM *block){
  1521. const int stride= 16*2;
  1522. const int xStride= 16;
  1523. int a,b,c,d,e;
  1524. a= block[stride*0 + xStride*0];
  1525. b= block[stride*0 + xStride*1];
  1526. c= block[stride*1 + xStride*0];
  1527. d= block[stride*1 + xStride*1];
  1528. e= a-b;
  1529. a= a+b;
  1530. b= c-d;
  1531. c= c+d;
  1532. block[stride*0 + xStride*0]= (a+c);
  1533. block[stride*0 + xStride*1]= (e+b);
  1534. block[stride*1 + xStride*0]= (a-c);
  1535. block[stride*1 + xStride*1]= (e-b);
  1536. }
  1537. #endif
  1538. /**
  1539. * gets the chroma qp.
  1540. */
  1541. static inline int get_chroma_qp(int chroma_qp_index_offset, int qscale){
  1542. return chroma_qp[clip(qscale + chroma_qp_index_offset, 0, 51)];
  1543. }
  1544. #if 0
  1545. static void h264_diff_dct_c(DCTELEM *block, uint8_t *src1, uint8_t *src2, int stride){
  1546. int i;
  1547. //FIXME try int temp instead of block
  1548. for(i=0; i<4; i++){
  1549. const int d0= src1[0 + i*stride] - src2[0 + i*stride];
  1550. const int d1= src1[1 + i*stride] - src2[1 + i*stride];
  1551. const int d2= src1[2 + i*stride] - src2[2 + i*stride];
  1552. const int d3= src1[3 + i*stride] - src2[3 + i*stride];
  1553. const int z0= d0 + d3;
  1554. const int z3= d0 - d3;
  1555. const int z1= d1 + d2;
  1556. const int z2= d1 - d2;
  1557. block[0 + 4*i]= z0 + z1;
  1558. block[1 + 4*i]= 2*z3 + z2;
  1559. block[2 + 4*i]= z0 - z1;
  1560. block[3 + 4*i]= z3 - 2*z2;
  1561. }
  1562. for(i=0; i<4; i++){
  1563. const int z0= block[0*4 + i] + block[3*4 + i];
  1564. const int z3= block[0*4 + i] - block[3*4 + i];
  1565. const int z1= block[1*4 + i] + block[2*4 + i];
  1566. const int z2= block[1*4 + i] - block[2*4 + i];
  1567. block[0*4 + i]= z0 + z1;
  1568. block[1*4 + i]= 2*z3 + z2;
  1569. block[2*4 + i]= z0 - z1;
  1570. block[3*4 + i]= z3 - 2*z2;
  1571. }
  1572. }
  1573. #endif
  1574. //FIXME need to check that this doesnt overflow signed 32 bit for low qp, i am not sure, it's very close
  1575. //FIXME check that gcc inlines this (and optimizes intra & seperate_dc stuff away)
  1576. static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int seperate_dc){
  1577. int i;
  1578. const int * const quant_table= quant_coeff[qscale];
  1579. const int bias= intra ? (1<<QUANT_SHIFT)/3 : (1<<QUANT_SHIFT)/6;
  1580. const unsigned int threshold1= (1<<QUANT_SHIFT) - bias - 1;
  1581. const unsigned int threshold2= (threshold1<<1);
  1582. int last_non_zero;
  1583. if(seperate_dc){
  1584. if(qscale<=18){
  1585. //avoid overflows
  1586. const int dc_bias= intra ? (1<<(QUANT_SHIFT-2))/3 : (1<<(QUANT_SHIFT-2))/6;
  1587. const unsigned int dc_threshold1= (1<<(QUANT_SHIFT-2)) - dc_bias - 1;
  1588. const unsigned int dc_threshold2= (dc_threshold1<<1);
  1589. int level= block[0]*quant_coeff[qscale+18][0];
  1590. if(((unsigned)(level+dc_threshold1))>dc_threshold2){
  1591. if(level>0){
  1592. level= (dc_bias + level)>>(QUANT_SHIFT-2);
  1593. block[0]= level;
  1594. }else{
  1595. level= (dc_bias - level)>>(QUANT_SHIFT-2);
  1596. block[0]= -level;
  1597. }
  1598. // last_non_zero = i;
  1599. }else{
  1600. block[0]=0;
  1601. }
  1602. }else{
  1603. const int dc_bias= intra ? (1<<(QUANT_SHIFT+1))/3 : (1<<(QUANT_SHIFT+1))/6;
  1604. const unsigned int dc_threshold1= (1<<(QUANT_SHIFT+1)) - dc_bias - 1;
  1605. const unsigned int dc_threshold2= (dc_threshold1<<1);
  1606. int level= block[0]*quant_table[0];
  1607. if(((unsigned)(level+dc_threshold1))>dc_threshold2){
  1608. if(level>0){
  1609. level= (dc_bias + level)>>(QUANT_SHIFT+1);
  1610. block[0]= level;
  1611. }else{
  1612. level= (dc_bias - level)>>(QUANT_SHIFT+1);
  1613. block[0]= -level;
  1614. }
  1615. // last_non_zero = i;
  1616. }else{
  1617. block[0]=0;
  1618. }
  1619. }
  1620. last_non_zero= 0;
  1621. i=1;
  1622. }else{
  1623. last_non_zero= -1;
  1624. i=0;
  1625. }
  1626. for(; i<16; i++){
  1627. const int j= scantable[i];
  1628. int level= block[j]*quant_table[j];
  1629. // if( bias+level >= (1<<(QMAT_SHIFT - 3))
  1630. // || bias-level >= (1<<(QMAT_SHIFT - 3))){
  1631. if(((unsigned)(level+threshold1))>threshold2){
  1632. if(level>0){
  1633. level= (bias + level)>>QUANT_SHIFT;
  1634. block[j]= level;
  1635. }else{
  1636. level= (bias - level)>>QUANT_SHIFT;
  1637. block[j]= -level;
  1638. }
  1639. last_non_zero = i;
  1640. }else{
  1641. block[j]=0;
  1642. }
  1643. }
  1644. return last_non_zero;
  1645. }
  1646. static void pred4x4_vertical_c(uint8_t *src, uint8_t *topright, int stride){
  1647. const uint32_t a= ((uint32_t*)(src-stride))[0];
  1648. ((uint32_t*)(src+0*stride))[0]= a;
  1649. ((uint32_t*)(src+1*stride))[0]= a;
  1650. ((uint32_t*)(src+2*stride))[0]= a;
  1651. ((uint32_t*)(src+3*stride))[0]= a;
  1652. }
  1653. static void pred4x4_horizontal_c(uint8_t *src, uint8_t *topright, int stride){
  1654. ((uint32_t*)(src+0*stride))[0]= src[-1+0*stride]*0x01010101;
  1655. ((uint32_t*)(src+1*stride))[0]= src[-1+1*stride]*0x01010101;
  1656. ((uint32_t*)(src+2*stride))[0]= src[-1+2*stride]*0x01010101;
  1657. ((uint32_t*)(src+3*stride))[0]= src[-1+3*stride]*0x01010101;
  1658. }
  1659. static void pred4x4_dc_c(uint8_t *src, uint8_t *topright, int stride){
  1660. const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride]
  1661. + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3;
  1662. ((uint32_t*)(src+0*stride))[0]=
  1663. ((uint32_t*)(src+1*stride))[0]=
  1664. ((uint32_t*)(src+2*stride))[0]=
  1665. ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;
  1666. }
  1667. static void pred4x4_left_dc_c(uint8_t *src, uint8_t *topright, int stride){
  1668. const int dc= ( src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2;
  1669. ((uint32_t*)(src+0*stride))[0]=
  1670. ((uint32_t*)(src+1*stride))[0]=
  1671. ((uint32_t*)(src+2*stride))[0]=
  1672. ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;
  1673. }
  1674. static void pred4x4_top_dc_c(uint8_t *src, uint8_t *topright, int stride){
  1675. const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2;
  1676. ((uint32_t*)(src+0*stride))[0]=
  1677. ((uint32_t*)(src+1*stride))[0]=
  1678. ((uint32_t*)(src+2*stride))[0]=
  1679. ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;
  1680. }
  1681. static void pred4x4_128_dc_c(uint8_t *src, uint8_t *topright, int stride){
  1682. ((uint32_t*)(src+0*stride))[0]=
  1683. ((uint32_t*)(src+1*stride))[0]=
  1684. ((uint32_t*)(src+2*stride))[0]=
  1685. ((uint32_t*)(src+3*stride))[0]= 128U*0x01010101U;
  1686. }
  1687. #define LOAD_TOP_RIGHT_EDGE\
  1688. const int t4= topright[0];\
  1689. const int t5= topright[1];\
  1690. const int t6= topright[2];\
  1691. const int t7= topright[3];\
  1692. #define LOAD_LEFT_EDGE\
  1693. const int l0= src[-1+0*stride];\
  1694. const int l1= src[-1+1*stride];\
  1695. const int l2= src[-1+2*stride];\
  1696. const int l3= src[-1+3*stride];\
  1697. #define LOAD_TOP_EDGE\
  1698. const int t0= src[ 0-1*stride];\
  1699. const int t1= src[ 1-1*stride];\
  1700. const int t2= src[ 2-1*stride];\
  1701. const int t3= src[ 3-1*stride];\
  1702. static void pred4x4_down_right_c(uint8_t *src, uint8_t *topright, int stride){
  1703. const int lt= src[-1-1*stride];
  1704. LOAD_TOP_EDGE
  1705. LOAD_LEFT_EDGE
  1706. src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2;
  1707. src[0+2*stride]=
  1708. src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2;
  1709. src[0+1*stride]=
  1710. src[1+2*stride]=
  1711. src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2;
  1712. src[0+0*stride]=
  1713. src[1+1*stride]=
  1714. src[2+2*stride]=
  1715. src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2;
  1716. src[1+0*stride]=
  1717. src[2+1*stride]=
  1718. src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2;
  1719. src[2+0*stride]=
  1720. src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;
  1721. src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2;
  1722. }
  1723. static void pred4x4_down_left_c(uint8_t *src, uint8_t *topright, int stride){
  1724. LOAD_TOP_EDGE
  1725. LOAD_TOP_RIGHT_EDGE
  1726. // LOAD_LEFT_EDGE
  1727. src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2;
  1728. src[1+0*stride]=
  1729. src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2;
  1730. src[2+0*stride]=
  1731. src[1+1*stride]=
  1732. src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2;
  1733. src[3+0*stride]=
  1734. src[2+1*stride]=
  1735. src[1+2*stride]=
  1736. src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2;
  1737. src[3+1*stride]=
  1738. src[2+2*stride]=
  1739. src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2;
  1740. src[3+2*stride]=
  1741. src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2;
  1742. src[3+3*stride]=(t6 + 3*t7 + 2)>>2;
  1743. }
  1744. static void pred4x4_vertical_right_c(uint8_t *src, uint8_t *topright, int stride){
  1745. const int lt= src[-1-1*stride];
  1746. LOAD_TOP_EDGE
  1747. LOAD_LEFT_EDGE
  1748. const __attribute__((unused)) int unu= l3;
  1749. src[0+0*stride]=
  1750. src[1+2*stride]=(lt + t0 + 1)>>1;
  1751. src[1+0*stride]=
  1752. src[2+2*stride]=(t0 + t1 + 1)>>1;
  1753. src[2+0*stride]=
  1754. src[3+2*stride]=(t1 + t2 + 1)>>1;
  1755. src[3+0*stride]=(t2 + t3 + 1)>>1;
  1756. src[0+1*stride]=
  1757. src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2;
  1758. src[1+1*stride]=
  1759. src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2;
  1760. src[2+1*stride]=
  1761. src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2;
  1762. src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2;
  1763. src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2;
  1764. src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;
  1765. }
  1766. static void pred4x4_vertical_left_c(uint8_t *src, uint8_t *topright, int stride){
  1767. LOAD_TOP_EDGE
  1768. LOAD_TOP_RIGHT_EDGE
  1769. const __attribute__((unused)) int unu= t7;
  1770. src[0+0*stride]=(t0 + t1 + 1)>>1;
  1771. src[1+0*stride]=
  1772. src[0+2*stride]=(t1 + t2 + 1)>>1;
  1773. src[2+0*stride]=
  1774. src[1+2*stride]=(t2 + t3 + 1)>>1;
  1775. src[3+0*stride]=
  1776. src[2+2*stride]=(t3 + t4+ 1)>>1;
  1777. src[3+2*stride]=(t4 + t5+ 1)>>1;
  1778. src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;
  1779. src[1+1*stride]=
  1780. src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2;
  1781. src[2+1*stride]=
  1782. src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2;
  1783. src[3+1*stride]=
  1784. src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2;
  1785. src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2;
  1786. }
  1787. static void pred4x4_horizontal_up_c(uint8_t *src, uint8_t *topright, int stride){
  1788. LOAD_LEFT_EDGE
  1789. src[0+0*stride]=(l0 + l1 + 1)>>1;
  1790. src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2;
  1791. src[2+0*stride]=
  1792. src[0+1*stride]=(l1 + l2 + 1)>>1;
  1793. src[3+0*stride]=
  1794. src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2;
  1795. src[2+1*stride]=
  1796. src[0+2*stride]=(l2 + l3 + 1)>>1;
  1797. src[3+1*stride]=
  1798. src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2;
  1799. src[3+2*stride]=
  1800. src[1+3*stride]=
  1801. src[0+3*stride]=
  1802. src[2+2*stride]=
  1803. src[2+3*stride]=
  1804. src[3+3*stride]=l3;
  1805. }
  1806. static void pred4x4_horizontal_down_c(uint8_t *src, uint8_t *topright, int stride){
  1807. const int lt= src[-1-1*stride];
  1808. LOAD_TOP_EDGE
  1809. LOAD_LEFT_EDGE
  1810. const __attribute__((unused)) int unu= t3;
  1811. src[0+0*stride]=
  1812. src[2+1*stride]=(lt + l0 + 1)>>1;
  1813. src[1+0*stride]=
  1814. src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2;
  1815. src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2;
  1816. src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2;
  1817. src[0+1*stride]=
  1818. src[2+2*stride]=(l0 + l1 + 1)>>1;
  1819. src[1+1*stride]=
  1820. src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2;
  1821. src[0+2*stride]=
  1822. src[2+3*stride]=(l1 + l2+ 1)>>1;
  1823. src[1+2*stride]=
  1824. src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;
  1825. src[0+3*stride]=(l2 + l3 + 1)>>1;
  1826. src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2;
  1827. }
  1828. static void pred16x16_vertical_c(uint8_t *src, int stride){
  1829. int i;
  1830. const uint32_t a= ((uint32_t*)(src-stride))[0];
  1831. const uint32_t b= ((uint32_t*)(src-stride))[1];
  1832. const uint32_t c= ((uint32_t*)(src-stride))[2];
  1833. const uint32_t d= ((uint32_t*)(src-stride))[3];
  1834. for(i=0; i<16; i++){
  1835. ((uint32_t*)(src+i*stride))[0]= a;
  1836. ((uint32_t*)(src+i*stride))[1]= b;
  1837. ((uint32_t*)(src+i*stride))[2]= c;
  1838. ((uint32_t*)(src+i*stride))[3]= d;
  1839. }
  1840. }
  1841. static void pred16x16_horizontal_c(uint8_t *src, int stride){
  1842. int i;
  1843. for(i=0; i<16; i++){
  1844. ((uint32_t*)(src+i*stride))[0]=
  1845. ((uint32_t*)(src+i*stride))[1]=
  1846. ((uint32_t*)(src+i*stride))[2]=
  1847. ((uint32_t*)(src+i*stride))[3]= src[-1+i*stride]*0x01010101;
  1848. }
  1849. }
  1850. static void pred16x16_dc_c(uint8_t *src, int stride){
  1851. int i, dc=0;
  1852. for(i=0;i<16; i++){
  1853. dc+= src[-1+i*stride];
  1854. }
  1855. for(i=0;i<16; i++){
  1856. dc+= src[i-stride];
  1857. }
  1858. dc= 0x01010101*((dc + 16)>>5);
  1859. for(i=0; i<16; i++){
  1860. ((uint32_t*)(src+i*stride))[0]=
  1861. ((uint32_t*)(src+i*stride))[1]=
  1862. ((uint32_t*)(src+i*stride))[2]=
  1863. ((uint32_t*)(src+i*stride))[3]= dc;
  1864. }
  1865. }
  1866. static void pred16x16_left_dc_c(uint8_t *src, int stride){
  1867. int i, dc=0;
  1868. for(i=0;i<16; i++){
  1869. dc+= src[-1+i*stride];
  1870. }
  1871. dc= 0x01010101*((dc + 8)>>4);
  1872. for(i=0; i<16; i++){
  1873. ((uint32_t*)(src+i*stride))[0]=
  1874. ((uint32_t*)(src+i*stride))[1]=
  1875. ((uint32_t*)(src+i*stride))[2]=
  1876. ((uint32_t*)(src+i*stride))[3]= dc;
  1877. }
  1878. }
  1879. static void pred16x16_top_dc_c(uint8_t *src, int stride){
  1880. int i, dc=0;
  1881. for(i=0;i<16; i++){
  1882. dc+= src[i-stride];
  1883. }
  1884. dc= 0x01010101*((dc + 8)>>4);
  1885. for(i=0; i<16; i++){
  1886. ((uint32_t*)(src+i*stride))[0]=
  1887. ((uint32_t*)(src+i*stride))[1]=
  1888. ((uint32_t*)(src+i*stride))[2]=
  1889. ((uint32_t*)(src+i*stride))[3]= dc;
  1890. }
  1891. }
  1892. static void pred16x16_128_dc_c(uint8_t *src, int stride){
  1893. int i;
  1894. for(i=0; i<16; i++){
  1895. ((uint32_t*)(src+i*stride))[0]=
  1896. ((uint32_t*)(src+i*stride))[1]=
  1897. ((uint32_t*)(src+i*stride))[2]=
  1898. ((uint32_t*)(src+i*stride))[3]= 0x01010101U*128U;
  1899. }
  1900. }
  1901. static inline void pred16x16_plane_compat_c(uint8_t *src, int stride, const int svq3){
  1902. int i, j, k;
  1903. int a;
  1904. uint8_t *cm = cropTbl + MAX_NEG_CROP;
  1905. const uint8_t * const src0 = src+7-stride;
  1906. const uint8_t *src1 = src+8*stride-1;
  1907. const uint8_t *src2 = src1-2*stride; // == src+6*stride-1;
  1908. int H = src0[1] - src0[-1];
  1909. int V = src1[0] - src2[ 0];
  1910. for(k=2; k<=8; ++k) {
  1911. src1 += stride; src2 -= stride;
  1912. H += k*(src0[k] - src0[-k]);
  1913. V += k*(src1[0] - src2[ 0]);
  1914. }
  1915. if(svq3){
  1916. H = ( 5*(H/4) ) / 16;
  1917. V = ( 5*(V/4) ) / 16;
  1918. /* required for 100% accuracy */
  1919. i = H; H = V; V = i;
  1920. }else{
  1921. H = ( 5*H+32 ) >> 6;
  1922. V = ( 5*V+32 ) >> 6;
  1923. }
  1924. a = 16*(src1[0] + src2[16] + 1) - 7*(V+H);
  1925. for(j=16; j>0; --j) {
  1926. int b = a;
  1927. a += V;
  1928. for(i=-16; i<0; i+=4) {
  1929. src[16+i] = cm[ (b ) >> 5 ];
  1930. src[17+i] = cm[ (b+ H) >> 5 ];
  1931. src[18+i] = cm[ (b+2*H) >> 5 ];
  1932. src[19+i] = cm[ (b+3*H) >> 5 ];
  1933. b += 4*H;
  1934. }
  1935. src += stride;
  1936. }
  1937. }
  1938. static void pred16x16_plane_c(uint8_t *src, int stride){
  1939. pred16x16_plane_compat_c(src, stride, 0);
  1940. }
  1941. static void pred8x8_vertical_c(uint8_t *src, int stride){
  1942. int i;
  1943. const uint32_t a= ((uint32_t*)(src-stride))[0];
  1944. const uint32_t b= ((uint32_t*)(src-stride))[1];
  1945. for(i=0; i<8; i++){
  1946. ((uint32_t*)(src+i*stride))[0]= a;
  1947. ((uint32_t*)(src+i*stride))[1]= b;
  1948. }
  1949. }
  1950. static void pred8x8_horizontal_c(uint8_t *src, int stride){
  1951. int i;
  1952. for(i=0; i<8; i++){
  1953. ((uint32_t*)(src+i*stride))[0]=
  1954. ((uint32_t*)(src+i*stride))[1]= src[-1+i*stride]*0x01010101;
  1955. }
  1956. }
  1957. static void pred8x8_128_dc_c(uint8_t *src, int stride){
  1958. int i;
  1959. for(i=0; i<8; i++){
  1960. ((uint32_t*)(src+i*stride))[0]=
  1961. ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U;
  1962. }
  1963. }
  1964. static void pred8x8_left_dc_c(uint8_t *src, int stride){
  1965. int i;
  1966. int dc0, dc2;
  1967. dc0=dc2=0;
  1968. for(i=0;i<4; i++){
  1969. dc0+= src[-1+i*stride];
  1970. dc2+= src[-1+(i+4)*stride];
  1971. }
  1972. dc0= 0x01010101*((dc0 + 2)>>2);
  1973. dc2= 0x01010101*((dc2 + 2)>>2);
  1974. for(i=0; i<4; i++){
  1975. ((uint32_t*)(src+i*stride))[0]=
  1976. ((uint32_t*)(src+i*stride))[1]= dc0;
  1977. }
  1978. for(i=4; i<8; i++){
  1979. ((uint32_t*)(src+i*stride))[0]=
  1980. ((uint32_t*)(src+i*stride))[1]= dc2;
  1981. }
  1982. }
  1983. static void pred8x8_top_dc_c(uint8_t *src, int stride){
  1984. int i;
  1985. int dc0, dc1;
  1986. dc0=dc1=0;
  1987. for(i=0;i<4; i++){
  1988. dc0+= src[i-stride];
  1989. dc1+= src[4+i-stride];
  1990. }
  1991. dc0= 0x01010101*((dc0 + 2)>>2);
  1992. dc1= 0x01010101*((dc1 + 2)>>2);
  1993. for(i=0; i<4; i++){
  1994. ((uint32_t*)(src+i*stride))[0]= dc0;
  1995. ((uint32_t*)(src+i*stride))[1]= dc1;
  1996. }
  1997. for(i=4; i<8; i++){
  1998. ((uint32_t*)(src+i*stride))[0]= dc0;
  1999. ((uint32_t*)(src+i*stride))[1]= dc1;
  2000. }
  2001. }
  2002. static void pred8x8_dc_c(uint8_t *src, int stride){
  2003. int i;
  2004. int dc0, dc1, dc2, dc3;
  2005. dc0=dc1=dc2=0;
  2006. for(i=0;i<4; i++){
  2007. dc0+= src[-1+i*stride] + src[i-stride];
  2008. dc1+= src[4+i-stride];
  2009. dc2+= src[-1+(i+4)*stride];
  2010. }
  2011. dc3= 0x01010101*((dc1 + dc2 + 4)>>3);
  2012. dc0= 0x01010101*((dc0 + 4)>>3);
  2013. dc1= 0x01010101*((dc1 + 2)>>2);
  2014. dc2= 0x01010101*((dc2 + 2)>>2);
  2015. for(i=0; i<4; i++){
  2016. ((uint32_t*)(src+i*stride))[0]= dc0;
  2017. ((uint32_t*)(src+i*stride))[1]= dc1;
  2018. }
  2019. for(i=4; i<8; i++){
  2020. ((uint32_t*)(src+i*stride))[0]= dc2;
  2021. ((uint32_t*)(src+i*stride))[1]= dc3;
  2022. }
  2023. }
  2024. static void pred8x8_plane_c(uint8_t *src, int stride){
  2025. int j, k;
  2026. int a;
  2027. uint8_t *cm = cropTbl + MAX_NEG_CROP;
  2028. const uint8_t * const src0 = src+3-stride;
  2029. const uint8_t *src1 = src+4*stride-1;
  2030. const uint8_t *src2 = src1-2*stride; // == src+2*stride-1;
  2031. int H = src0[1] - src0[-1];
  2032. int V = src1[0] - src2[ 0];
  2033. for(k=2; k<=4; ++k) {
  2034. src1 += stride; src2 -= stride;
  2035. H += k*(src0[k] - src0[-k]);
  2036. V += k*(src1[0] - src2[ 0]);
  2037. }
  2038. H = ( 17*H+16 ) >> 5;
  2039. V = ( 17*V+16 ) >> 5;
  2040. a = 16*(src1[0] + src2[8]+1) - 3*(V+H);
  2041. for(j=8; j>0; --j) {
  2042. int b = a;
  2043. a += V;
  2044. src[0] = cm[ (b ) >> 5 ];
  2045. src[1] = cm[ (b+ H) >> 5 ];
  2046. src[2] = cm[ (b+2*H) >> 5 ];
  2047. src[3] = cm[ (b+3*H) >> 5 ];
  2048. src[4] = cm[ (b+4*H) >> 5 ];
  2049. src[5] = cm[ (b+5*H) >> 5 ];
  2050. src[6] = cm[ (b+6*H) >> 5 ];
  2051. src[7] = cm[ (b+7*H) >> 5 ];
  2052. src += stride;
  2053. }
  2054. }
  2055. #define SRC(x,y) src[(x)+(y)*stride]
  2056. #define PL(y) \
  2057. const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2;
  2058. #define PREDICT_8x8_LOAD_LEFT \
  2059. const int l0 = ((has_topleft ? SRC(-1,-1) : SRC(-1,0)) \
  2060. + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; \
  2061. PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) \
  2062. const int l7 attribute_unused = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2
  2063. #define PT(x) \
  2064. const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
  2065. #define PREDICT_8x8_LOAD_TOP \
  2066. const int t0 = ((has_topleft ? SRC(-1,-1) : SRC(0,-1)) \
  2067. + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; \
  2068. PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) \
  2069. const int t7 attribute_unused = ((has_topright ? SRC(8,-1) : SRC(7,-1)) \
  2070. + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2
  2071. #define PTR(x) \
  2072. t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
  2073. #define PREDICT_8x8_LOAD_TOPRIGHT \
  2074. int t8, t9, t10, t11, t12, t13, t14, t15; \
  2075. if(has_topright) { \
  2076. PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) \
  2077. t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; \
  2078. } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1);
  2079. #define PREDICT_8x8_LOAD_TOPLEFT \
  2080. const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2
  2081. #define PREDICT_8x8_DC(v) \
  2082. int y; \
  2083. for( y = 0; y < 8; y++ ) { \
  2084. ((uint32_t*)src)[0] = \
  2085. ((uint32_t*)src)[1] = v; \
  2086. src += stride; \
  2087. }
  2088. static void pred8x8l_128_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2089. {
  2090. PREDICT_8x8_DC(0x80808080);
  2091. }
  2092. static void pred8x8l_left_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2093. {
  2094. PREDICT_8x8_LOAD_LEFT;
  2095. const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3) * 0x01010101;
  2096. PREDICT_8x8_DC(dc);
  2097. }
  2098. static void pred8x8l_top_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2099. {
  2100. PREDICT_8x8_LOAD_TOP;
  2101. const uint32_t dc = ((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3) * 0x01010101;
  2102. PREDICT_8x8_DC(dc);
  2103. }
  2104. static void pred8x8l_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2105. {
  2106. PREDICT_8x8_LOAD_LEFT;
  2107. PREDICT_8x8_LOAD_TOP;
  2108. const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7
  2109. +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4) * 0x01010101;
  2110. PREDICT_8x8_DC(dc);
  2111. }
  2112. static void pred8x8l_horizontal_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2113. {
  2114. PREDICT_8x8_LOAD_LEFT;
  2115. #define ROW(y) ((uint32_t*)(src+y*stride))[0] =\
  2116. ((uint32_t*)(src+y*stride))[1] = 0x01010101 * l##y
  2117. ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7);
  2118. #undef ROW
  2119. }
  2120. static void pred8x8l_vertical_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2121. {
  2122. int y;
  2123. PREDICT_8x8_LOAD_TOP;
  2124. src[0] = t0;
  2125. src[1] = t1;
  2126. src[2] = t2;
  2127. src[3] = t3;
  2128. src[4] = t4;
  2129. src[5] = t5;
  2130. src[6] = t6;
  2131. src[7] = t7;
  2132. for( y = 1; y < 8; y++ )
  2133. *(uint64_t*)(src+y*stride) = *(uint64_t*)src;
  2134. }
  2135. static void pred8x8l_down_left_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2136. {
  2137. PREDICT_8x8_LOAD_TOP;
  2138. PREDICT_8x8_LOAD_TOPRIGHT;
  2139. SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2;
  2140. SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2;
  2141. SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2;
  2142. SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2;
  2143. SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2;
  2144. SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2;
  2145. 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;
  2146. 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;
  2147. 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;
  2148. SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2;
  2149. SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2;
  2150. SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2;
  2151. SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2;
  2152. SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2;
  2153. SRC(7,7)= (t14 + 3*t15 + 2) >> 2;
  2154. }
  2155. static void pred8x8l_down_right_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2156. {
  2157. PREDICT_8x8_LOAD_TOP;
  2158. PREDICT_8x8_LOAD_LEFT;
  2159. PREDICT_8x8_LOAD_TOPLEFT;
  2160. SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2;
  2161. SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2;
  2162. SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2;
  2163. SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2;
  2164. SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2;
  2165. SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2;
  2166. 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;
  2167. 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;
  2168. 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;
  2169. SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2;
  2170. SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2;
  2171. SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2;
  2172. SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2;
  2173. SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2;
  2174. SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2;
  2175. }
  2176. static void pred8x8l_vertical_right_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2177. {
  2178. PREDICT_8x8_LOAD_TOP;
  2179. PREDICT_8x8_LOAD_LEFT;
  2180. PREDICT_8x8_LOAD_TOPLEFT;
  2181. SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2;
  2182. SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2;
  2183. SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2;
  2184. SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2;
  2185. SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2;
  2186. SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2;
  2187. SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2;
  2188. SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1;
  2189. SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2;
  2190. SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1;
  2191. SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2;
  2192. SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1;
  2193. SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2;
  2194. SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1;
  2195. SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2;
  2196. SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1;
  2197. SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2;
  2198. SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1;
  2199. SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2;
  2200. SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1;
  2201. SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2;
  2202. SRC(7,0)= (t6 + t7 + 1) >> 1;
  2203. }
  2204. static void pred8x8l_horizontal_down_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2205. {
  2206. PREDICT_8x8_LOAD_TOP;
  2207. PREDICT_8x8_LOAD_LEFT;
  2208. PREDICT_8x8_LOAD_TOPLEFT;
  2209. SRC(0,7)= (l6 + l7 + 1) >> 1;
  2210. SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2;
  2211. SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1;
  2212. SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2;
  2213. SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1;
  2214. SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2;
  2215. SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1;
  2216. SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2;
  2217. SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1;
  2218. SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2;
  2219. SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1;
  2220. SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2;
  2221. SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1;
  2222. SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2;
  2223. SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1;
  2224. SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2;
  2225. SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2;
  2226. SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2;
  2227. SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2;
  2228. SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2;
  2229. SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2;
  2230. SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2;
  2231. }
  2232. static void pred8x8l_vertical_left_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2233. {
  2234. PREDICT_8x8_LOAD_TOP;
  2235. PREDICT_8x8_LOAD_TOPRIGHT;
  2236. SRC(0,0)= (t0 + t1 + 1) >> 1;
  2237. SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2;
  2238. SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1;
  2239. SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2;
  2240. SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1;
  2241. SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2;
  2242. SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1;
  2243. SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2;
  2244. SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1;
  2245. SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2;
  2246. SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1;
  2247. SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2;
  2248. SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1;
  2249. SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2;
  2250. SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1;
  2251. SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2;
  2252. SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1;
  2253. SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2;
  2254. SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1;
  2255. SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2;
  2256. SRC(7,6)= (t10 + t11 + 1) >> 1;
  2257. SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2;
  2258. }
  2259. static void pred8x8l_horizontal_up_c(uint8_t *src, int has_topleft, int has_topright, int stride)
  2260. {
  2261. PREDICT_8x8_LOAD_LEFT;
  2262. SRC(0,0)= (l0 + l1 + 1) >> 1;
  2263. SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2;
  2264. SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1;
  2265. SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2;
  2266. SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1;
  2267. SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2;
  2268. SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1;
  2269. SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2;
  2270. SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1;
  2271. SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2;
  2272. SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1;
  2273. SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2;
  2274. SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1;
  2275. SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2;
  2276. SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)=
  2277. SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)=
  2278. SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)=
  2279. SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7;
  2280. }
  2281. #undef PREDICT_8x8_LOAD_LEFT
  2282. #undef PREDICT_8x8_LOAD_TOP
  2283. #undef PREDICT_8x8_LOAD_TOPLEFT
  2284. #undef PREDICT_8x8_LOAD_TOPRIGHT
  2285. #undef PREDICT_8x8_DC
  2286. #undef PTR
  2287. #undef PT
  2288. #undef PL
  2289. #undef SRC
  2290. static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,
  2291. uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
  2292. int src_x_offset, int src_y_offset,
  2293. qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){
  2294. MpegEncContext * const s = &h->s;
  2295. const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;
  2296. const int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;
  2297. const int luma_xy= (mx&3) + ((my&3)<<2);
  2298. uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*s->linesize;
  2299. uint8_t * src_cb= pic->data[1] + (mx>>3) + (my>>3)*s->uvlinesize;
  2300. uint8_t * src_cr= pic->data[2] + (mx>>3) + (my>>3)*s->uvlinesize;
  2301. int extra_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16; //FIXME increase edge?, IMHO not worth it
  2302. int extra_height= extra_width;
  2303. int emu=0;
  2304. const int full_mx= mx>>2;
  2305. const int full_my= my>>2;
  2306. const int pic_width = 16*s->mb_width;
  2307. const int pic_height = 16*s->mb_height;
  2308. if(!pic->data[0])
  2309. return;
  2310. if(mx&7) extra_width -= 3;
  2311. if(my&7) extra_height -= 3;
  2312. if( full_mx < 0-extra_width
  2313. || full_my < 0-extra_height
  2314. || full_mx + 16/*FIXME*/ > pic_width + extra_width
  2315. || full_my + 16/*FIXME*/ > pic_height + extra_height){
  2316. ff_emulated_edge_mc(s->edge_emu_buffer, src_y - 2 - 2*s->linesize, s->linesize, 16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);
  2317. src_y= s->edge_emu_buffer + 2 + 2*s->linesize;
  2318. emu=1;
  2319. }
  2320. qpix_op[luma_xy](dest_y, src_y, s->linesize); //FIXME try variable height perhaps?
  2321. if(!square){
  2322. qpix_op[luma_xy](dest_y + delta, src_y + delta, s->linesize);
  2323. }
  2324. if(s->flags&CODEC_FLAG_GRAY) return;
  2325. if(emu){
  2326. ff_emulated_edge_mc(s->edge_emu_buffer, src_cb, s->uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);
  2327. src_cb= s->edge_emu_buffer;
  2328. }
  2329. chroma_op(dest_cb, src_cb, s->uvlinesize, chroma_height, mx&7, my&7);
  2330. if(emu){
  2331. ff_emulated_edge_mc(s->edge_emu_buffer, src_cr, s->uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);
  2332. src_cr= s->edge_emu_buffer;
  2333. }
  2334. chroma_op(dest_cr, src_cr, s->uvlinesize, chroma_height, mx&7, my&7);
  2335. }
  2336. static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta,
  2337. uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
  2338. int x_offset, int y_offset,
  2339. qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
  2340. qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
  2341. int list0, int list1){
  2342. MpegEncContext * const s = &h->s;
  2343. qpel_mc_func *qpix_op= qpix_put;
  2344. h264_chroma_mc_func chroma_op= chroma_put;
  2345. dest_y += 2*x_offset + 2*y_offset*s-> linesize;
  2346. dest_cb += x_offset + y_offset*s->uvlinesize;
  2347. dest_cr += x_offset + y_offset*s->uvlinesize;
  2348. x_offset += 8*s->mb_x;
  2349. y_offset += 8*s->mb_y;
  2350. if(list0){
  2351. Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];
  2352. mc_dir_part(h, ref, n, square, chroma_height, delta, 0,
  2353. dest_y, dest_cb, dest_cr, x_offset, y_offset,
  2354. qpix_op, chroma_op);
  2355. qpix_op= qpix_avg;
  2356. chroma_op= chroma_avg;
  2357. }
  2358. if(list1){
  2359. Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];
  2360. mc_dir_part(h, ref, n, square, chroma_height, delta, 1,
  2361. dest_y, dest_cb, dest_cr, x_offset, y_offset,
  2362. qpix_op, chroma_op);
  2363. }
  2364. }
  2365. static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta,
  2366. uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
  2367. int x_offset, int y_offset,
  2368. qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
  2369. h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,
  2370. h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,
  2371. int list0, int list1){
  2372. MpegEncContext * const s = &h->s;
  2373. dest_y += 2*x_offset + 2*y_offset*s-> linesize;
  2374. dest_cb += x_offset + y_offset*s->uvlinesize;
  2375. dest_cr += x_offset + y_offset*s->uvlinesize;
  2376. x_offset += 8*s->mb_x;
  2377. y_offset += 8*s->mb_y;
  2378. if(list0 && list1){
  2379. /* don't optimize for luma-only case, since B-frames usually
  2380. * use implicit weights => chroma too. */
  2381. uint8_t *tmp_cb = s->obmc_scratchpad;
  2382. uint8_t *tmp_cr = tmp_cb + 8*s->uvlinesize;
  2383. uint8_t *tmp_y = tmp_cr + 8*s->uvlinesize;
  2384. int refn0 = h->ref_cache[0][ scan8[n] ];
  2385. int refn1 = h->ref_cache[1][ scan8[n] ];
  2386. mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0,
  2387. dest_y, dest_cb, dest_cr,
  2388. x_offset, y_offset, qpix_put, chroma_put);
  2389. mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1,
  2390. tmp_y, tmp_cb, tmp_cr,
  2391. x_offset, y_offset, qpix_put, chroma_put);
  2392. if(h->use_weight == 2){
  2393. int weight0 = h->implicit_weight[refn0][refn1];
  2394. int weight1 = 64 - weight0;
  2395. luma_weight_avg( dest_y, tmp_y, s-> linesize, 5, weight0, weight1, 0);
  2396. chroma_weight_avg(dest_cb, tmp_cb, s->uvlinesize, 5, weight0, weight1, 0);
  2397. chroma_weight_avg(dest_cr, tmp_cr, s->uvlinesize, 5, weight0, weight1, 0);
  2398. }else{
  2399. luma_weight_avg(dest_y, tmp_y, s->linesize, h->luma_log2_weight_denom,
  2400. h->luma_weight[0][refn0], h->luma_weight[1][refn1],
  2401. h->luma_offset[0][refn0] + h->luma_offset[1][refn1]);
  2402. chroma_weight_avg(dest_cb, tmp_cb, s->uvlinesize, h->chroma_log2_weight_denom,
  2403. h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0],
  2404. h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]);
  2405. chroma_weight_avg(dest_cr, tmp_cr, s->uvlinesize, h->chroma_log2_weight_denom,
  2406. h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1],
  2407. h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]);
  2408. }
  2409. }else{
  2410. int list = list1 ? 1 : 0;
  2411. int refn = h->ref_cache[list][ scan8[n] ];
  2412. Picture *ref= &h->ref_list[list][refn];
  2413. mc_dir_part(h, ref, n, square, chroma_height, delta, list,
  2414. dest_y, dest_cb, dest_cr, x_offset, y_offset,
  2415. qpix_put, chroma_put);
  2416. luma_weight_op(dest_y, s->linesize, h->luma_log2_weight_denom,
  2417. h->luma_weight[list][refn], h->luma_offset[list][refn]);
  2418. if(h->use_weight_chroma){
  2419. chroma_weight_op(dest_cb, s->uvlinesize, h->chroma_log2_weight_denom,
  2420. h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]);
  2421. chroma_weight_op(dest_cr, s->uvlinesize, h->chroma_log2_weight_denom,
  2422. h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]);
  2423. }
  2424. }
  2425. }
  2426. static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta,
  2427. uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
  2428. int x_offset, int y_offset,
  2429. qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
  2430. qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
  2431. h264_weight_func *weight_op, h264_biweight_func *weight_avg,
  2432. int list0, int list1){
  2433. if((h->use_weight==2 && list0 && list1
  2434. && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32))
  2435. || h->use_weight==1)
  2436. mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
  2437. x_offset, y_offset, qpix_put, chroma_put,
  2438. weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1);
  2439. else
  2440. mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
  2441. x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1);
  2442. }
  2443. static inline void prefetch_motion(H264Context *h, int list){
  2444. /* fetch pixels for estimated mv 4 macroblocks ahead
  2445. * optimized for 64byte cache lines */
  2446. MpegEncContext * const s = &h->s;
  2447. const int refn = h->ref_cache[list][scan8[0]];
  2448. if(refn >= 0){
  2449. const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8;
  2450. const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y;
  2451. uint8_t **src= h->ref_list[list][refn].data;
  2452. int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
  2453. s->dsp.prefetch(src[0]+off, s->linesize, 4);
  2454. off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
  2455. s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);
  2456. }
  2457. }
  2458. static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
  2459. qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),
  2460. qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),
  2461. h264_weight_func *weight_op, h264_biweight_func *weight_avg){
  2462. MpegEncContext * const s = &h->s;
  2463. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  2464. const int mb_type= s->current_picture.mb_type[mb_xy];
  2465. assert(IS_INTER(mb_type));
  2466. prefetch_motion(h, 0);
  2467. if(IS_16X16(mb_type)){
  2468. mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,
  2469. qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],
  2470. &weight_op[0], &weight_avg[0],
  2471. IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
  2472. }else if(IS_16X8(mb_type)){
  2473. mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0,
  2474. qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
  2475. &weight_op[1], &weight_avg[1],
  2476. IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
  2477. mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4,
  2478. qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
  2479. &weight_op[1], &weight_avg[1],
  2480. IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
  2481. }else if(IS_8X16(mb_type)){
  2482. mc_part(h, 0, 0, 8, 8*s->linesize, dest_y, dest_cb, dest_cr, 0, 0,
  2483. qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
  2484. &weight_op[2], &weight_avg[2],
  2485. IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
  2486. mc_part(h, 4, 0, 8, 8*s->linesize, dest_y, dest_cb, dest_cr, 4, 0,
  2487. qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
  2488. &weight_op[2], &weight_avg[2],
  2489. IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
  2490. }else{
  2491. int i;
  2492. assert(IS_8X8(mb_type));
  2493. for(i=0; i<4; i++){
  2494. const int sub_mb_type= h->sub_mb_type[i];
  2495. const int n= 4*i;
  2496. int x_offset= (i&1)<<2;
  2497. int y_offset= (i&2)<<1;
  2498. if(IS_SUB_8X8(sub_mb_type)){
  2499. mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,
  2500. qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
  2501. &weight_op[3], &weight_avg[3],
  2502. IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
  2503. }else if(IS_SUB_8X4(sub_mb_type)){
  2504. mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset,
  2505. qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
  2506. &weight_op[4], &weight_avg[4],
  2507. IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
  2508. mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,
  2509. qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
  2510. &weight_op[4], &weight_avg[4],
  2511. IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
  2512. }else if(IS_SUB_4X8(sub_mb_type)){
  2513. mc_part(h, n , 0, 4, 4*s->linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,
  2514. qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
  2515. &weight_op[5], &weight_avg[5],
  2516. IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
  2517. mc_part(h, n+1, 0, 4, 4*s->linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,
  2518. qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
  2519. &weight_op[5], &weight_avg[5],
  2520. IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
  2521. }else{
  2522. int j;
  2523. assert(IS_SUB_4X4(sub_mb_type));
  2524. for(j=0; j<4; j++){
  2525. int sub_x_offset= x_offset + 2*(j&1);
  2526. int sub_y_offset= y_offset + (j&2);
  2527. mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,
  2528. qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
  2529. &weight_op[6], &weight_avg[6],
  2530. IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
  2531. }
  2532. }
  2533. }
  2534. }
  2535. prefetch_motion(h, 1);
  2536. }
  2537. static void decode_init_vlc(H264Context *h){
  2538. static int done = 0;
  2539. if (!done) {
  2540. int i;
  2541. done = 1;
  2542. init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
  2543. &chroma_dc_coeff_token_len [0], 1, 1,
  2544. &chroma_dc_coeff_token_bits[0], 1, 1, 1);
  2545. for(i=0; i<4; i++){
  2546. init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
  2547. &coeff_token_len [i][0], 1, 1,
  2548. &coeff_token_bits[i][0], 1, 1, 1);
  2549. }
  2550. for(i=0; i<3; i++){
  2551. init_vlc(&chroma_dc_total_zeros_vlc[i], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
  2552. &chroma_dc_total_zeros_len [i][0], 1, 1,
  2553. &chroma_dc_total_zeros_bits[i][0], 1, 1, 1);
  2554. }
  2555. for(i=0; i<15; i++){
  2556. init_vlc(&total_zeros_vlc[i], TOTAL_ZEROS_VLC_BITS, 16,
  2557. &total_zeros_len [i][0], 1, 1,
  2558. &total_zeros_bits[i][0], 1, 1, 1);
  2559. }
  2560. for(i=0; i<6; i++){
  2561. init_vlc(&run_vlc[i], RUN_VLC_BITS, 7,
  2562. &run_len [i][0], 1, 1,
  2563. &run_bits[i][0], 1, 1, 1);
  2564. }
  2565. init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
  2566. &run_len [6][0], 1, 1,
  2567. &run_bits[6][0], 1, 1, 1);
  2568. }
  2569. }
  2570. /**
  2571. * Sets the intra prediction function pointers.
  2572. */
  2573. static void init_pred_ptrs(H264Context *h){
  2574. // MpegEncContext * const s = &h->s;
  2575. h->pred4x4[VERT_PRED ]= pred4x4_vertical_c;
  2576. h->pred4x4[HOR_PRED ]= pred4x4_horizontal_c;
  2577. h->pred4x4[DC_PRED ]= pred4x4_dc_c;
  2578. h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_c;
  2579. h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c;
  2580. h->pred4x4[VERT_RIGHT_PRED ]= pred4x4_vertical_right_c;
  2581. h->pred4x4[HOR_DOWN_PRED ]= pred4x4_horizontal_down_c;
  2582. h->pred4x4[VERT_LEFT_PRED ]= pred4x4_vertical_left_c;
  2583. h->pred4x4[HOR_UP_PRED ]= pred4x4_horizontal_up_c;
  2584. h->pred4x4[LEFT_DC_PRED ]= pred4x4_left_dc_c;
  2585. h->pred4x4[TOP_DC_PRED ]= pred4x4_top_dc_c;
  2586. h->pred4x4[DC_128_PRED ]= pred4x4_128_dc_c;
  2587. h->pred8x8l[VERT_PRED ]= pred8x8l_vertical_c;
  2588. h->pred8x8l[HOR_PRED ]= pred8x8l_horizontal_c;
  2589. h->pred8x8l[DC_PRED ]= pred8x8l_dc_c;
  2590. h->pred8x8l[DIAG_DOWN_LEFT_PRED ]= pred8x8l_down_left_c;
  2591. h->pred8x8l[DIAG_DOWN_RIGHT_PRED]= pred8x8l_down_right_c;
  2592. h->pred8x8l[VERT_RIGHT_PRED ]= pred8x8l_vertical_right_c;
  2593. h->pred8x8l[HOR_DOWN_PRED ]= pred8x8l_horizontal_down_c;
  2594. h->pred8x8l[VERT_LEFT_PRED ]= pred8x8l_vertical_left_c;
  2595. h->pred8x8l[HOR_UP_PRED ]= pred8x8l_horizontal_up_c;
  2596. h->pred8x8l[LEFT_DC_PRED ]= pred8x8l_left_dc_c;
  2597. h->pred8x8l[TOP_DC_PRED ]= pred8x8l_top_dc_c;
  2598. h->pred8x8l[DC_128_PRED ]= pred8x8l_128_dc_c;
  2599. h->pred8x8[DC_PRED8x8 ]= pred8x8_dc_c;
  2600. h->pred8x8[VERT_PRED8x8 ]= pred8x8_vertical_c;
  2601. h->pred8x8[HOR_PRED8x8 ]= pred8x8_horizontal_c;
  2602. h->pred8x8[PLANE_PRED8x8 ]= pred8x8_plane_c;
  2603. h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_c;
  2604. h->pred8x8[TOP_DC_PRED8x8 ]= pred8x8_top_dc_c;
  2605. h->pred8x8[DC_128_PRED8x8 ]= pred8x8_128_dc_c;
  2606. h->pred16x16[DC_PRED8x8 ]= pred16x16_dc_c;
  2607. h->pred16x16[VERT_PRED8x8 ]= pred16x16_vertical_c;
  2608. h->pred16x16[HOR_PRED8x8 ]= pred16x16_horizontal_c;
  2609. h->pred16x16[PLANE_PRED8x8 ]= pred16x16_plane_c;
  2610. h->pred16x16[LEFT_DC_PRED8x8]= pred16x16_left_dc_c;
  2611. h->pred16x16[TOP_DC_PRED8x8 ]= pred16x16_top_dc_c;
  2612. h->pred16x16[DC_128_PRED8x8 ]= pred16x16_128_dc_c;
  2613. }
  2614. static void free_tables(H264Context *h){
  2615. av_freep(&h->intra4x4_pred_mode);
  2616. av_freep(&h->chroma_pred_mode_table);
  2617. av_freep(&h->cbp_table);
  2618. av_freep(&h->mvd_table[0]);
  2619. av_freep(&h->mvd_table[1]);
  2620. av_freep(&h->direct_table);
  2621. av_freep(&h->non_zero_count);
  2622. av_freep(&h->slice_table_base);
  2623. av_freep(&h->top_borders[1]);
  2624. av_freep(&h->top_borders[0]);
  2625. h->slice_table= NULL;
  2626. av_freep(&h->mb2b_xy);
  2627. av_freep(&h->mb2b8_xy);
  2628. av_freep(&h->s.obmc_scratchpad);
  2629. }
  2630. static void init_dequant8_coeff_table(H264Context *h){
  2631. int i,q,x;
  2632. const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly
  2633. h->dequant8_coeff[0] = h->dequant8_buffer[0];
  2634. h->dequant8_coeff[1] = h->dequant8_buffer[1];
  2635. for(i=0; i<2; i++ ){
  2636. if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){
  2637. h->dequant8_coeff[1] = h->dequant8_buffer[0];
  2638. break;
  2639. }
  2640. for(q=0; q<52; q++){
  2641. int shift = div6[q];
  2642. int idx = rem6[q];
  2643. for(x=0; x<64; x++)
  2644. h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] =
  2645. ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] *
  2646. h->pps.scaling_matrix8[i][x]) << shift;
  2647. }
  2648. }
  2649. }
  2650. static void init_dequant4_coeff_table(H264Context *h){
  2651. int i,j,q,x;
  2652. const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly
  2653. for(i=0; i<6; i++ ){
  2654. h->dequant4_coeff[i] = h->dequant4_buffer[i];
  2655. for(j=0; j<i; j++){
  2656. if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){
  2657. h->dequant4_coeff[i] = h->dequant4_buffer[j];
  2658. break;
  2659. }
  2660. }
  2661. if(j<i)
  2662. continue;
  2663. for(q=0; q<52; q++){
  2664. int shift = div6[q] + 2;
  2665. int idx = rem6[q];
  2666. for(x=0; x<16; x++)
  2667. h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] =
  2668. ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] *
  2669. h->pps.scaling_matrix4[i][x]) << shift;
  2670. }
  2671. }
  2672. }
  2673. static void init_dequant_tables(H264Context *h){
  2674. int i,x;
  2675. init_dequant4_coeff_table(h);
  2676. if(h->pps.transform_8x8_mode)
  2677. init_dequant8_coeff_table(h);
  2678. if(h->sps.transform_bypass){
  2679. for(i=0; i<6; i++)
  2680. for(x=0; x<16; x++)
  2681. h->dequant4_coeff[i][0][x] = 1<<6;
  2682. if(h->pps.transform_8x8_mode)
  2683. for(i=0; i<2; i++)
  2684. for(x=0; x<64; x++)
  2685. h->dequant8_coeff[i][0][x] = 1<<6;
  2686. }
  2687. }
  2688. /**
  2689. * allocates tables.
  2690. * needs width/height
  2691. */
  2692. static int alloc_tables(H264Context *h){
  2693. MpegEncContext * const s = &h->s;
  2694. const int big_mb_num= s->mb_stride * (s->mb_height+1);
  2695. int x,y;
  2696. CHECKED_ALLOCZ(h->intra4x4_pred_mode, big_mb_num * 8 * sizeof(uint8_t))
  2697. CHECKED_ALLOCZ(h->non_zero_count , big_mb_num * 16 * sizeof(uint8_t))
  2698. CHECKED_ALLOCZ(h->slice_table_base , big_mb_num * sizeof(uint8_t))
  2699. CHECKED_ALLOCZ(h->top_borders[0] , s->mb_width * (16+8+8) * sizeof(uint8_t))
  2700. CHECKED_ALLOCZ(h->top_borders[1] , s->mb_width * (16+8+8) * sizeof(uint8_t))
  2701. CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t))
  2702. if( h->pps.cabac ) {
  2703. CHECKED_ALLOCZ(h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t))
  2704. CHECKED_ALLOCZ(h->mvd_table[0], 32*big_mb_num * sizeof(uint16_t));
  2705. CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t));
  2706. CHECKED_ALLOCZ(h->direct_table, 32*big_mb_num * sizeof(uint8_t));
  2707. }
  2708. memset(h->slice_table_base, -1, big_mb_num * sizeof(uint8_t));
  2709. h->slice_table= h->slice_table_base + s->mb_stride + 1;
  2710. CHECKED_ALLOCZ(h->mb2b_xy , big_mb_num * sizeof(uint32_t));
  2711. CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t));
  2712. for(y=0; y<s->mb_height; y++){
  2713. for(x=0; x<s->mb_width; x++){
  2714. const int mb_xy= x + y*s->mb_stride;
  2715. const int b_xy = 4*x + 4*y*h->b_stride;
  2716. const int b8_xy= 2*x + 2*y*h->b8_stride;
  2717. h->mb2b_xy [mb_xy]= b_xy;
  2718. h->mb2b8_xy[mb_xy]= b8_xy;
  2719. }
  2720. }
  2721. s->obmc_scratchpad = NULL;
  2722. if(!h->dequant4_coeff[0])
  2723. init_dequant_tables(h);
  2724. return 0;
  2725. fail:
  2726. free_tables(h);
  2727. return -1;
  2728. }
  2729. static void common_init(H264Context *h){
  2730. MpegEncContext * const s = &h->s;
  2731. s->width = s->avctx->width;
  2732. s->height = s->avctx->height;
  2733. s->codec_id= s->avctx->codec->id;
  2734. init_pred_ptrs(h);
  2735. h->dequant_coeff_pps= -1;
  2736. s->unrestricted_mv=1;
  2737. s->decode=1; //FIXME
  2738. memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));
  2739. memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));
  2740. }
  2741. static int decode_init(AVCodecContext *avctx){
  2742. H264Context *h= avctx->priv_data;
  2743. MpegEncContext * const s = &h->s;
  2744. MPV_decode_defaults(s);
  2745. s->avctx = avctx;
  2746. common_init(h);
  2747. s->out_format = FMT_H264;
  2748. s->workaround_bugs= avctx->workaround_bugs;
  2749. // set defaults
  2750. // s->decode_mb= ff_h263_decode_mb;
  2751. s->low_delay= 1;
  2752. avctx->pix_fmt= PIX_FMT_YUV420P;
  2753. decode_init_vlc(h);
  2754. if(avctx->extradata_size > 0 && avctx->extradata &&
  2755. *(char *)avctx->extradata == 1){
  2756. h->is_avc = 1;
  2757. h->got_avcC = 0;
  2758. } else {
  2759. h->is_avc = 0;
  2760. }
  2761. return 0;
  2762. }
  2763. static int frame_start(H264Context *h){
  2764. MpegEncContext * const s = &h->s;
  2765. int i;
  2766. if(MPV_frame_start(s, s->avctx) < 0)
  2767. return -1;
  2768. ff_er_frame_start(s);
  2769. assert(s->linesize && s->uvlinesize);
  2770. for(i=0; i<16; i++){
  2771. h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3);
  2772. h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3);
  2773. }
  2774. for(i=0; i<4; i++){
  2775. h->block_offset[16+i]=
  2776. h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);
  2777. h->block_offset[24+16+i]=
  2778. h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3);
  2779. }
  2780. /* can't be in alloc_tables because linesize isn't known there.
  2781. * FIXME: redo bipred weight to not require extra buffer? */
  2782. if(!s->obmc_scratchpad)
  2783. s->obmc_scratchpad = av_malloc(16*s->linesize + 2*8*s->uvlinesize);
  2784. // s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;
  2785. return 0;
  2786. }
  2787. static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){
  2788. MpegEncContext * const s = &h->s;
  2789. int i;
  2790. src_y -= linesize;
  2791. src_cb -= uvlinesize;
  2792. src_cr -= uvlinesize;
  2793. // There are two lines saved, the line above the the top macroblock of a pair,
  2794. // and the line above the bottom macroblock
  2795. h->left_border[0]= h->top_borders[0][s->mb_x][15];
  2796. for(i=1; i<17; i++){
  2797. h->left_border[i]= src_y[15+i* linesize];
  2798. }
  2799. *(uint64_t*)(h->top_borders[0][s->mb_x]+0)= *(uint64_t*)(src_y + 16*linesize);
  2800. *(uint64_t*)(h->top_borders[0][s->mb_x]+8)= *(uint64_t*)(src_y +8+16*linesize);
  2801. if(!(s->flags&CODEC_FLAG_GRAY)){
  2802. h->left_border[17 ]= h->top_borders[0][s->mb_x][16+7];
  2803. h->left_border[17+9]= h->top_borders[0][s->mb_x][24+7];
  2804. for(i=1; i<9; i++){
  2805. h->left_border[i+17 ]= src_cb[7+i*uvlinesize];
  2806. h->left_border[i+17+9]= src_cr[7+i*uvlinesize];
  2807. }
  2808. *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+8*uvlinesize);
  2809. *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+8*uvlinesize);
  2810. }
  2811. }
  2812. 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){
  2813. MpegEncContext * const s = &h->s;
  2814. int temp8, i;
  2815. uint64_t temp64;
  2816. int deblock_left = (s->mb_x > 0);
  2817. int deblock_top = (s->mb_y > 0);
  2818. src_y -= linesize + 1;
  2819. src_cb -= uvlinesize + 1;
  2820. src_cr -= uvlinesize + 1;
  2821. #define XCHG(a,b,t,xchg)\
  2822. t= a;\
  2823. if(xchg)\
  2824. a= b;\
  2825. b= t;
  2826. if(deblock_left){
  2827. for(i = !deblock_top; i<17; i++){
  2828. XCHG(h->left_border[i ], src_y [i* linesize], temp8, xchg);
  2829. }
  2830. }
  2831. if(deblock_top){
  2832. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg);
  2833. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1);
  2834. if(s->mb_x+1 < s->mb_width){
  2835. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1);
  2836. }
  2837. }
  2838. if(!(s->flags&CODEC_FLAG_GRAY)){
  2839. if(deblock_left){
  2840. for(i = !deblock_top; i<9; i++){
  2841. XCHG(h->left_border[i+17 ], src_cb[i*uvlinesize], temp8, xchg);
  2842. XCHG(h->left_border[i+17+9], src_cr[i*uvlinesize], temp8, xchg);
  2843. }
  2844. }
  2845. if(deblock_top){
  2846. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1);
  2847. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1);
  2848. }
  2849. }
  2850. }
  2851. static inline void backup_pair_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){
  2852. MpegEncContext * const s = &h->s;
  2853. int i;
  2854. src_y -= 2 * linesize;
  2855. src_cb -= 2 * uvlinesize;
  2856. src_cr -= 2 * uvlinesize;
  2857. // There are two lines saved, the line above the the top macroblock of a pair,
  2858. // and the line above the bottom macroblock
  2859. h->left_border[0]= h->top_borders[0][s->mb_x][15];
  2860. h->left_border[1]= h->top_borders[1][s->mb_x][15];
  2861. for(i=2; i<34; i++){
  2862. h->left_border[i]= src_y[15+i* linesize];
  2863. }
  2864. *(uint64_t*)(h->top_borders[0][s->mb_x]+0)= *(uint64_t*)(src_y + 32*linesize);
  2865. *(uint64_t*)(h->top_borders[0][s->mb_x]+8)= *(uint64_t*)(src_y +8+32*linesize);
  2866. *(uint64_t*)(h->top_borders[1][s->mb_x]+0)= *(uint64_t*)(src_y + 33*linesize);
  2867. *(uint64_t*)(h->top_borders[1][s->mb_x]+8)= *(uint64_t*)(src_y +8+33*linesize);
  2868. if(!(s->flags&CODEC_FLAG_GRAY)){
  2869. h->left_border[34 ]= h->top_borders[0][s->mb_x][16+7];
  2870. h->left_border[34+ 1]= h->top_borders[1][s->mb_x][16+7];
  2871. h->left_border[34+18 ]= h->top_borders[0][s->mb_x][24+7];
  2872. h->left_border[34+18+1]= h->top_borders[1][s->mb_x][24+7];
  2873. for(i=2; i<18; i++){
  2874. h->left_border[i+34 ]= src_cb[7+i*uvlinesize];
  2875. h->left_border[i+34+18]= src_cr[7+i*uvlinesize];
  2876. }
  2877. *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+16*uvlinesize);
  2878. *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+16*uvlinesize);
  2879. *(uint64_t*)(h->top_borders[1][s->mb_x]+16)= *(uint64_t*)(src_cb+17*uvlinesize);
  2880. *(uint64_t*)(h->top_borders[1][s->mb_x]+24)= *(uint64_t*)(src_cr+17*uvlinesize);
  2881. }
  2882. }
  2883. 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){
  2884. MpegEncContext * const s = &h->s;
  2885. int temp8, i;
  2886. uint64_t temp64;
  2887. int deblock_left = (s->mb_x > 0);
  2888. int deblock_top = (s->mb_y > 0);
  2889. 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);
  2890. src_y -= 2 * linesize + 1;
  2891. src_cb -= 2 * uvlinesize + 1;
  2892. src_cr -= 2 * uvlinesize + 1;
  2893. #define XCHG(a,b,t,xchg)\
  2894. t= a;\
  2895. if(xchg)\
  2896. a= b;\
  2897. b= t;
  2898. if(deblock_left){
  2899. for(i = (!deblock_top)<<1; i<34; i++){
  2900. XCHG(h->left_border[i ], src_y [i* linesize], temp8, xchg);
  2901. }
  2902. }
  2903. if(deblock_top){
  2904. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg);
  2905. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1);
  2906. XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+0), *(uint64_t*)(src_y +1 +linesize), temp64, xchg);
  2907. XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+8), *(uint64_t*)(src_y +9 +linesize), temp64, 1);
  2908. }
  2909. if(!(s->flags&CODEC_FLAG_GRAY)){
  2910. if(deblock_left){
  2911. for(i = (!deblock_top) << 1; i<18; i++){
  2912. XCHG(h->left_border[i+34 ], src_cb[i*uvlinesize], temp8, xchg);
  2913. XCHG(h->left_border[i+34+18], src_cr[i*uvlinesize], temp8, xchg);
  2914. }
  2915. }
  2916. if(deblock_top){
  2917. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1);
  2918. XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1);
  2919. XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+16), *(uint64_t*)(src_cb+1 +uvlinesize), temp64, 1);
  2920. XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+24), *(uint64_t*)(src_cr+1 +uvlinesize), temp64, 1);
  2921. }
  2922. }
  2923. }
  2924. static void hl_decode_mb(H264Context *h){
  2925. MpegEncContext * const s = &h->s;
  2926. const int mb_x= s->mb_x;
  2927. const int mb_y= s->mb_y;
  2928. const int mb_xy= mb_x + mb_y*s->mb_stride;
  2929. const int mb_type= s->current_picture.mb_type[mb_xy];
  2930. uint8_t *dest_y, *dest_cb, *dest_cr;
  2931. int linesize, uvlinesize /*dct_offset*/;
  2932. int i;
  2933. int *block_offset = &h->block_offset[0];
  2934. const unsigned int bottom = mb_y & 1;
  2935. const int transform_bypass = (s->qscale == 0 && h->sps.transform_bypass);
  2936. void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
  2937. void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
  2938. if(!s->decode)
  2939. return;
  2940. dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16;
  2941. dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
  2942. dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
  2943. if (h->mb_field_decoding_flag) {
  2944. linesize = s->linesize * 2;
  2945. uvlinesize = s->uvlinesize * 2;
  2946. block_offset = &h->block_offset[24];
  2947. if(mb_y&1){ //FIXME move out of this func?
  2948. dest_y -= s->linesize*15;
  2949. dest_cb-= s->uvlinesize*7;
  2950. dest_cr-= s->uvlinesize*7;
  2951. }
  2952. } else {
  2953. linesize = s->linesize;
  2954. uvlinesize = s->uvlinesize;
  2955. // dct_offset = s->linesize * 16;
  2956. }
  2957. if(transform_bypass){
  2958. idct_dc_add =
  2959. idct_add = IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4;
  2960. }else if(IS_8x8DCT(mb_type)){
  2961. idct_dc_add = s->dsp.h264_idct8_dc_add;
  2962. idct_add = s->dsp.h264_idct8_add;
  2963. }else{
  2964. idct_dc_add = s->dsp.h264_idct_dc_add;
  2965. idct_add = s->dsp.h264_idct_add;
  2966. }
  2967. if (IS_INTRA_PCM(mb_type)) {
  2968. unsigned int x, y;
  2969. // The pixels are stored in h->mb array in the same order as levels,
  2970. // copy them in output in the correct order.
  2971. for(i=0; i<16; i++) {
  2972. for (y=0; y<4; y++) {
  2973. for (x=0; x<4; x++) {
  2974. *(dest_y + block_offset[i] + y*linesize + x) = h->mb[i*16+y*4+x];
  2975. }
  2976. }
  2977. }
  2978. for(i=16; i<16+4; i++) {
  2979. for (y=0; y<4; y++) {
  2980. for (x=0; x<4; x++) {
  2981. *(dest_cb + block_offset[i] + y*uvlinesize + x) = h->mb[i*16+y*4+x];
  2982. }
  2983. }
  2984. }
  2985. for(i=20; i<20+4; i++) {
  2986. for (y=0; y<4; y++) {
  2987. for (x=0; x<4; x++) {
  2988. *(dest_cr + block_offset[i] + y*uvlinesize + x) = h->mb[i*16+y*4+x];
  2989. }
  2990. }
  2991. }
  2992. } else {
  2993. if(IS_INTRA(mb_type)){
  2994. if(h->deblocking_filter) {
  2995. if (h->mb_aff_frame) {
  2996. if (!bottom)
  2997. xchg_pair_border(h, dest_y, dest_cb, dest_cr, s->linesize, s->uvlinesize, 1);
  2998. } else {
  2999. xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1);
  3000. }
  3001. }
  3002. if(!(s->flags&CODEC_FLAG_GRAY)){
  3003. h->pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);
  3004. h->pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);
  3005. }
  3006. if(IS_INTRA4x4(mb_type)){
  3007. if(!s->encoding){
  3008. if(IS_8x8DCT(mb_type)){
  3009. for(i=0; i<16; i+=4){
  3010. uint8_t * const ptr= dest_y + block_offset[i];
  3011. const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
  3012. const int nnz = h->non_zero_count_cache[ scan8[i] ];
  3013. h->pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,
  3014. (h->topright_samples_available<<(i+1))&0x8000, linesize);
  3015. if(nnz){
  3016. if(nnz == 1 && h->mb[i*16])
  3017. idct_dc_add(ptr, h->mb + i*16, linesize);
  3018. else
  3019. idct_add(ptr, h->mb + i*16, linesize);
  3020. }
  3021. }
  3022. }else
  3023. for(i=0; i<16; i++){
  3024. uint8_t * const ptr= dest_y + block_offset[i];
  3025. uint8_t *topright;
  3026. const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
  3027. int nnz, tr;
  3028. if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){
  3029. const int topright_avail= (h->topright_samples_available<<i)&0x8000;
  3030. assert(mb_y || linesize <= block_offset[i]);
  3031. if(!topright_avail){
  3032. tr= ptr[3 - linesize]*0x01010101;
  3033. topright= (uint8_t*) &tr;
  3034. }else
  3035. topright= ptr + 4 - linesize;
  3036. }else
  3037. topright= NULL;
  3038. h->pred4x4[ dir ](ptr, topright, linesize);
  3039. nnz = h->non_zero_count_cache[ scan8[i] ];
  3040. if(nnz){
  3041. if(s->codec_id == CODEC_ID_H264){
  3042. if(nnz == 1 && h->mb[i*16])
  3043. idct_dc_add(ptr, h->mb + i*16, linesize);
  3044. else
  3045. idct_add(ptr, h->mb + i*16, linesize);
  3046. }else
  3047. svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);
  3048. }
  3049. }
  3050. }
  3051. }else{
  3052. h->pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);
  3053. if(s->codec_id == CODEC_ID_H264){
  3054. if(!transform_bypass)
  3055. h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[IS_INTRA(mb_type) ? 0:3][s->qscale][0]);
  3056. }else
  3057. svq3_luma_dc_dequant_idct_c(h->mb, s->qscale);
  3058. }
  3059. if(h->deblocking_filter) {
  3060. if (h->mb_aff_frame) {
  3061. if (bottom) {
  3062. uint8_t *pair_dest_y = s->current_picture.data[0] + ((mb_y-1) * 16* s->linesize ) + mb_x * 16;
  3063. uint8_t *pair_dest_cb = s->current_picture.data[1] + ((mb_y-1) * 8 * s->uvlinesize) + mb_x * 8;
  3064. uint8_t *pair_dest_cr = s->current_picture.data[2] + ((mb_y-1) * 8 * s->uvlinesize) + mb_x * 8;
  3065. s->mb_y--;
  3066. xchg_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize, 0);
  3067. s->mb_y++;
  3068. }
  3069. } else {
  3070. xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0);
  3071. }
  3072. }
  3073. }else if(s->codec_id == CODEC_ID_H264){
  3074. hl_motion(h, dest_y, dest_cb, dest_cr,
  3075. s->dsp.put_h264_qpel_pixels_tab, s->dsp.put_h264_chroma_pixels_tab,
  3076. s->dsp.avg_h264_qpel_pixels_tab, s->dsp.avg_h264_chroma_pixels_tab,
  3077. s->dsp.weight_h264_pixels_tab, s->dsp.biweight_h264_pixels_tab);
  3078. }
  3079. if(!IS_INTRA4x4(mb_type)){
  3080. if(s->codec_id == CODEC_ID_H264){
  3081. if(IS_INTRA16x16(mb_type)){
  3082. for(i=0; i<16; i++){
  3083. if(h->non_zero_count_cache[ scan8[i] ])
  3084. idct_add(dest_y + block_offset[i], h->mb + i*16, linesize);
  3085. else if(h->mb[i*16])
  3086. idct_dc_add(dest_y + block_offset[i], h->mb + i*16, linesize);
  3087. }
  3088. }else{
  3089. const int di = IS_8x8DCT(mb_type) ? 4 : 1;
  3090. for(i=0; i<16; i+=di){
  3091. int nnz = h->non_zero_count_cache[ scan8[i] ];
  3092. if(nnz){
  3093. if(nnz==1 && h->mb[i*16])
  3094. idct_dc_add(dest_y + block_offset[i], h->mb + i*16, linesize);
  3095. else
  3096. idct_add(dest_y + block_offset[i], h->mb + i*16, linesize);
  3097. }
  3098. }
  3099. }
  3100. }else{
  3101. for(i=0; i<16; i++){
  3102. if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below
  3103. uint8_t * const ptr= dest_y + block_offset[i];
  3104. svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0);
  3105. }
  3106. }
  3107. }
  3108. }
  3109. if(!(s->flags&CODEC_FLAG_GRAY)){
  3110. uint8_t *dest[2] = {dest_cb, dest_cr};
  3111. if(transform_bypass){
  3112. idct_add = idct_dc_add = s->dsp.add_pixels4;
  3113. }else{
  3114. idct_add = s->dsp.h264_idct_add;
  3115. idct_dc_add = s->dsp.h264_idct_dc_add;
  3116. 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]);
  3117. 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]);
  3118. }
  3119. if(s->codec_id == CODEC_ID_H264){
  3120. for(i=16; i<16+8; i++){
  3121. if(h->non_zero_count_cache[ scan8[i] ])
  3122. idct_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
  3123. else if(h->mb[i*16])
  3124. idct_dc_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
  3125. }
  3126. }else{
  3127. for(i=16; i<16+8; i++){
  3128. if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
  3129. uint8_t * const ptr= dest[(i&4)>>2] + block_offset[i];
  3130. svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2);
  3131. }
  3132. }
  3133. }
  3134. }
  3135. }
  3136. if(h->deblocking_filter) {
  3137. if (h->mb_aff_frame) {
  3138. const int mb_y = s->mb_y - 1;
  3139. uint8_t *pair_dest_y, *pair_dest_cb, *pair_dest_cr;
  3140. const int mb_xy= mb_x + mb_y*s->mb_stride;
  3141. const int mb_type_top = s->current_picture.mb_type[mb_xy];
  3142. const int mb_type_bottom= s->current_picture.mb_type[mb_xy+s->mb_stride];
  3143. uint8_t tmp = s->current_picture.data[1][384];
  3144. if (!bottom) return;
  3145. pair_dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16;
  3146. pair_dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
  3147. pair_dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
  3148. backup_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize);
  3149. // TODO deblock a pair
  3150. // top
  3151. s->mb_y--;
  3152. 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);
  3153. fill_caches(h, mb_type_top, 1); //FIXME don't fill stuff which isn't used by filter_mb
  3154. filter_mb(h, mb_x, mb_y, pair_dest_y, pair_dest_cb, pair_dest_cr, linesize, uvlinesize);
  3155. if (tmp != s->current_picture.data[1][384]) {
  3156. tprintf("modified pixel 8,1 (1)\n");
  3157. }
  3158. // bottom
  3159. s->mb_y++;
  3160. tprintf("call mbaff filter_mb\n");
  3161. fill_caches(h, mb_type_bottom, 1); //FIXME don't fill stuff which isn't used by filter_mb
  3162. filter_mb(h, mb_x, mb_y+1, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
  3163. if (tmp != s->current_picture.data[1][384]) {
  3164. tprintf("modified pixel 8,1 (2)\n");
  3165. }
  3166. } else {
  3167. tprintf("call filter_mb\n");
  3168. backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
  3169. fill_caches(h, mb_type, 1); //FIXME don't fill stuff which isn't used by filter_mb
  3170. filter_mb(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
  3171. }
  3172. }
  3173. }
  3174. /**
  3175. * fills the default_ref_list.
  3176. */
  3177. static int fill_default_ref_list(H264Context *h){
  3178. MpegEncContext * const s = &h->s;
  3179. int i;
  3180. int smallest_poc_greater_than_current = -1;
  3181. Picture sorted_short_ref[32];
  3182. if(h->slice_type==B_TYPE){
  3183. int out_i;
  3184. int limit= INT_MIN;
  3185. /* sort frame according to poc in B slice */
  3186. for(out_i=0; out_i<h->short_ref_count; out_i++){
  3187. int best_i=INT_MIN;
  3188. int best_poc=INT_MAX;
  3189. for(i=0; i<h->short_ref_count; i++){
  3190. const int poc= h->short_ref[i]->poc;
  3191. if(poc > limit && poc < best_poc){
  3192. best_poc= poc;
  3193. best_i= i;
  3194. }
  3195. }
  3196. assert(best_i != INT_MIN);
  3197. limit= best_poc;
  3198. sorted_short_ref[out_i]= *h->short_ref[best_i];
  3199. 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);
  3200. if (-1 == smallest_poc_greater_than_current) {
  3201. if (h->short_ref[best_i]->poc >= s->current_picture_ptr->poc) {
  3202. smallest_poc_greater_than_current = out_i;
  3203. }
  3204. }
  3205. }
  3206. }
  3207. if(s->picture_structure == PICT_FRAME){
  3208. if(h->slice_type==B_TYPE){
  3209. int list;
  3210. tprintf("current poc: %d, smallest_poc_greater_than_current: %d\n", s->current_picture_ptr->poc, smallest_poc_greater_than_current);
  3211. // find the largest poc
  3212. for(list=0; list<2; list++){
  3213. int index = 0;
  3214. int j= -99;
  3215. int step= list ? -1 : 1;
  3216. for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++, j+=step) {
  3217. while(j<0 || j>= h->short_ref_count){
  3218. if(j != -99 && step == (list ? -1 : 1))
  3219. return -1;
  3220. step = -step;
  3221. j= smallest_poc_greater_than_current + (step>>1);
  3222. }
  3223. if(sorted_short_ref[j].reference != 3) continue;
  3224. h->default_ref_list[list][index ]= sorted_short_ref[j];
  3225. h->default_ref_list[list][index++].pic_id= sorted_short_ref[j].frame_num;
  3226. }
  3227. for(i = 0; i < 16 && index < h->ref_count[ list ]; i++){
  3228. if(h->long_ref[i] == NULL) continue;
  3229. if(h->long_ref[i]->reference != 3) continue;
  3230. h->default_ref_list[ list ][index ]= *h->long_ref[i];
  3231. h->default_ref_list[ list ][index++].pic_id= i;;
  3232. }
  3233. if(list && (smallest_poc_greater_than_current<=0 || smallest_poc_greater_than_current>=h->short_ref_count) && (1 < index)){
  3234. // swap the two first elements of L1 when
  3235. // L0 and L1 are identical
  3236. Picture temp= h->default_ref_list[1][0];
  3237. h->default_ref_list[1][0] = h->default_ref_list[1][1];
  3238. h->default_ref_list[1][1] = temp;
  3239. }
  3240. if(index < h->ref_count[ list ])
  3241. memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index));
  3242. }
  3243. }else{
  3244. int index=0;
  3245. for(i=0; i<h->short_ref_count; i++){
  3246. if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit
  3247. h->default_ref_list[0][index ]= *h->short_ref[i];
  3248. h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num;
  3249. }
  3250. for(i = 0; i < 16; i++){
  3251. if(h->long_ref[i] == NULL) continue;
  3252. if(h->long_ref[i]->reference != 3) continue;
  3253. h->default_ref_list[0][index ]= *h->long_ref[i];
  3254. h->default_ref_list[0][index++].pic_id= i;;
  3255. }
  3256. if(index < h->ref_count[0])
  3257. memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index));
  3258. }
  3259. }else{ //FIELD
  3260. if(h->slice_type==B_TYPE){
  3261. }else{
  3262. //FIXME second field balh
  3263. }
  3264. }
  3265. #ifdef TRACE
  3266. for (i=0; i<h->ref_count[0]; i++) {
  3267. 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]);
  3268. }
  3269. if(h->slice_type==B_TYPE){
  3270. for (i=0; i<h->ref_count[1]; i++) {
  3271. 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]);
  3272. }
  3273. }
  3274. #endif
  3275. return 0;
  3276. }
  3277. static void print_short_term(H264Context *h);
  3278. static void print_long_term(H264Context *h);
  3279. static int decode_ref_pic_list_reordering(H264Context *h){
  3280. MpegEncContext * const s = &h->s;
  3281. int list, index;
  3282. print_short_term(h);
  3283. print_long_term(h);
  3284. if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move before func
  3285. for(list=0; list<2; list++){
  3286. memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]);
  3287. if(get_bits1(&s->gb)){
  3288. int pred= h->curr_pic_num;
  3289. for(index=0; ; index++){
  3290. int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb);
  3291. int pic_id;
  3292. int i;
  3293. Picture *ref = NULL;
  3294. if(reordering_of_pic_nums_idc==3)
  3295. break;
  3296. if(index >= h->ref_count[list]){
  3297. av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n");
  3298. return -1;
  3299. }
  3300. if(reordering_of_pic_nums_idc<3){
  3301. if(reordering_of_pic_nums_idc<2){
  3302. const int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1;
  3303. if(abs_diff_pic_num >= h->max_pic_num){
  3304. av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n");
  3305. return -1;
  3306. }
  3307. if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num;
  3308. else pred+= abs_diff_pic_num;
  3309. pred &= h->max_pic_num - 1;
  3310. for(i= h->short_ref_count-1; i>=0; i--){
  3311. ref = h->short_ref[i];
  3312. assert(ref->reference == 3);
  3313. assert(!ref->long_ref);
  3314. if(ref->data[0] != NULL && ref->frame_num == pred && ref->long_ref == 0) // ignore non existing pictures by testing data[0] pointer
  3315. break;
  3316. }
  3317. if(i>=0)
  3318. ref->pic_id= ref->frame_num;
  3319. }else{
  3320. pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx
  3321. ref = h->long_ref[pic_id];
  3322. ref->pic_id= pic_id;
  3323. assert(ref->reference == 3);
  3324. assert(ref->long_ref);
  3325. i=0;
  3326. }
  3327. if (i < 0) {
  3328. av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n");
  3329. memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME
  3330. } else {
  3331. for(i=index; i+1<h->ref_count[list]; i++){
  3332. if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id)
  3333. break;
  3334. }
  3335. for(; i > index; i--){
  3336. h->ref_list[list][i]= h->ref_list[list][i-1];
  3337. }
  3338. h->ref_list[list][index]= *ref;
  3339. }
  3340. }else{
  3341. av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n");
  3342. return -1;
  3343. }
  3344. }
  3345. }
  3346. if(h->slice_type!=B_TYPE) break;
  3347. }
  3348. for(list=0; list<2; list++){
  3349. for(index= 0; index < h->ref_count[list]; index++){
  3350. if(!h->ref_list[list][index].data[0])
  3351. h->ref_list[list][index]= s->current_picture;
  3352. }
  3353. if(h->slice_type!=B_TYPE) break;
  3354. }
  3355. if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred)
  3356. direct_dist_scale_factor(h);
  3357. direct_ref_list_init(h);
  3358. return 0;
  3359. }
  3360. static int pred_weight_table(H264Context *h){
  3361. MpegEncContext * const s = &h->s;
  3362. int list, i;
  3363. int luma_def, chroma_def;
  3364. h->use_weight= 0;
  3365. h->use_weight_chroma= 0;
  3366. h->luma_log2_weight_denom= get_ue_golomb(&s->gb);
  3367. h->chroma_log2_weight_denom= get_ue_golomb(&s->gb);
  3368. luma_def = 1<<h->luma_log2_weight_denom;
  3369. chroma_def = 1<<h->chroma_log2_weight_denom;
  3370. for(list=0; list<2; list++){
  3371. for(i=0; i<h->ref_count[list]; i++){
  3372. int luma_weight_flag, chroma_weight_flag;
  3373. luma_weight_flag= get_bits1(&s->gb);
  3374. if(luma_weight_flag){
  3375. h->luma_weight[list][i]= get_se_golomb(&s->gb);
  3376. h->luma_offset[list][i]= get_se_golomb(&s->gb);
  3377. if( h->luma_weight[list][i] != luma_def
  3378. || h->luma_offset[list][i] != 0)
  3379. h->use_weight= 1;
  3380. }else{
  3381. h->luma_weight[list][i]= luma_def;
  3382. h->luma_offset[list][i]= 0;
  3383. }
  3384. chroma_weight_flag= get_bits1(&s->gb);
  3385. if(chroma_weight_flag){
  3386. int j;
  3387. for(j=0; j<2; j++){
  3388. h->chroma_weight[list][i][j]= get_se_golomb(&s->gb);
  3389. h->chroma_offset[list][i][j]= get_se_golomb(&s->gb);
  3390. if( h->chroma_weight[list][i][j] != chroma_def
  3391. || h->chroma_offset[list][i][j] != 0)
  3392. h->use_weight_chroma= 1;
  3393. }
  3394. }else{
  3395. int j;
  3396. for(j=0; j<2; j++){
  3397. h->chroma_weight[list][i][j]= chroma_def;
  3398. h->chroma_offset[list][i][j]= 0;
  3399. }
  3400. }
  3401. }
  3402. if(h->slice_type != B_TYPE) break;
  3403. }
  3404. h->use_weight= h->use_weight || h->use_weight_chroma;
  3405. return 0;
  3406. }
  3407. static void implicit_weight_table(H264Context *h){
  3408. MpegEncContext * const s = &h->s;
  3409. int ref0, ref1;
  3410. int cur_poc = s->current_picture_ptr->poc;
  3411. if( h->ref_count[0] == 1 && h->ref_count[1] == 1
  3412. && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){
  3413. h->use_weight= 0;
  3414. h->use_weight_chroma= 0;
  3415. return;
  3416. }
  3417. h->use_weight= 2;
  3418. h->use_weight_chroma= 2;
  3419. h->luma_log2_weight_denom= 5;
  3420. h->chroma_log2_weight_denom= 5;
  3421. /* FIXME: MBAFF */
  3422. for(ref0=0; ref0 < h->ref_count[0]; ref0++){
  3423. int poc0 = h->ref_list[0][ref0].poc;
  3424. for(ref1=0; ref1 < h->ref_count[1]; ref1++){
  3425. int poc1 = h->ref_list[1][ref1].poc;
  3426. int td = clip(poc1 - poc0, -128, 127);
  3427. if(td){
  3428. int tb = clip(cur_poc - poc0, -128, 127);
  3429. int tx = (16384 + (ABS(td) >> 1)) / td;
  3430. int dist_scale_factor = clip((tb*tx + 32) >> 6, -1024, 1023) >> 2;
  3431. if(dist_scale_factor < -64 || dist_scale_factor > 128)
  3432. h->implicit_weight[ref0][ref1] = 32;
  3433. else
  3434. h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor;
  3435. }else
  3436. h->implicit_weight[ref0][ref1] = 32;
  3437. }
  3438. }
  3439. }
  3440. static inline void unreference_pic(H264Context *h, Picture *pic){
  3441. int i;
  3442. pic->reference=0;
  3443. if(pic == h->delayed_output_pic)
  3444. pic->reference=1;
  3445. else{
  3446. for(i = 0; h->delayed_pic[i]; i++)
  3447. if(pic == h->delayed_pic[i]){
  3448. pic->reference=1;
  3449. break;
  3450. }
  3451. }
  3452. }
  3453. /**
  3454. * instantaneous decoder refresh.
  3455. */
  3456. static void idr(H264Context *h){
  3457. int i;
  3458. for(i=0; i<16; i++){
  3459. if (h->long_ref[i] != NULL) {
  3460. unreference_pic(h, h->long_ref[i]);
  3461. h->long_ref[i]= NULL;
  3462. }
  3463. }
  3464. h->long_ref_count=0;
  3465. for(i=0; i<h->short_ref_count; i++){
  3466. unreference_pic(h, h->short_ref[i]);
  3467. h->short_ref[i]= NULL;
  3468. }
  3469. h->short_ref_count=0;
  3470. }
  3471. /* forget old pics after a seek */
  3472. static void flush_dpb(AVCodecContext *avctx){
  3473. H264Context *h= avctx->priv_data;
  3474. int i;
  3475. for(i=0; i<16; i++) {
  3476. if(h->delayed_pic[i])
  3477. h->delayed_pic[i]->reference= 0;
  3478. h->delayed_pic[i]= NULL;
  3479. }
  3480. if(h->delayed_output_pic)
  3481. h->delayed_output_pic->reference= 0;
  3482. h->delayed_output_pic= NULL;
  3483. idr(h);
  3484. if(h->s.current_picture_ptr)
  3485. h->s.current_picture_ptr->reference= 0;
  3486. }
  3487. /**
  3488. *
  3489. * @return the removed picture or NULL if an error occurs
  3490. */
  3491. static Picture * remove_short(H264Context *h, int frame_num){
  3492. MpegEncContext * const s = &h->s;
  3493. int i;
  3494. if(s->avctx->debug&FF_DEBUG_MMCO)
  3495. av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);
  3496. for(i=0; i<h->short_ref_count; i++){
  3497. Picture *pic= h->short_ref[i];
  3498. if(s->avctx->debug&FF_DEBUG_MMCO)
  3499. av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
  3500. if(pic->frame_num == frame_num){
  3501. h->short_ref[i]= NULL;
  3502. memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*));
  3503. h->short_ref_count--;
  3504. return pic;
  3505. }
  3506. }
  3507. return NULL;
  3508. }
  3509. /**
  3510. *
  3511. * @return the removed picture or NULL if an error occurs
  3512. */
  3513. static Picture * remove_long(H264Context *h, int i){
  3514. Picture *pic;
  3515. pic= h->long_ref[i];
  3516. h->long_ref[i]= NULL;
  3517. if(pic) h->long_ref_count--;
  3518. return pic;
  3519. }
  3520. /**
  3521. * print short term list
  3522. */
  3523. static void print_short_term(H264Context *h) {
  3524. uint32_t i;
  3525. if(h->s.avctx->debug&FF_DEBUG_MMCO) {
  3526. av_log(h->s.avctx, AV_LOG_DEBUG, "short term list:\n");
  3527. for(i=0; i<h->short_ref_count; i++){
  3528. Picture *pic= h->short_ref[i];
  3529. av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]);
  3530. }
  3531. }
  3532. }
  3533. /**
  3534. * print long term list
  3535. */
  3536. static void print_long_term(H264Context *h) {
  3537. uint32_t i;
  3538. if(h->s.avctx->debug&FF_DEBUG_MMCO) {
  3539. av_log(h->s.avctx, AV_LOG_DEBUG, "long term list:\n");
  3540. for(i = 0; i < 16; i++){
  3541. Picture *pic= h->long_ref[i];
  3542. if (pic) {
  3543. av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]);
  3544. }
  3545. }
  3546. }
  3547. }
  3548. /**
  3549. * Executes the reference picture marking (memory management control operations).
  3550. */
  3551. static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){
  3552. MpegEncContext * const s = &h->s;
  3553. int i, j;
  3554. int current_is_long=0;
  3555. Picture *pic;
  3556. if((s->avctx->debug&FF_DEBUG_MMCO) && mmco_count==0)
  3557. av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n");
  3558. for(i=0; i<mmco_count; i++){
  3559. if(s->avctx->debug&FF_DEBUG_MMCO)
  3560. 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);
  3561. switch(mmco[i].opcode){
  3562. case MMCO_SHORT2UNUSED:
  3563. pic= remove_short(h, mmco[i].short_frame_num);
  3564. if(pic)
  3565. unreference_pic(h, pic);
  3566. else if(s->avctx->debug&FF_DEBUG_MMCO)
  3567. av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_short() failure\n");
  3568. break;
  3569. case MMCO_SHORT2LONG:
  3570. pic= remove_long(h, mmco[i].long_index);
  3571. if(pic) unreference_pic(h, pic);
  3572. h->long_ref[ mmco[i].long_index ]= remove_short(h, mmco[i].short_frame_num);
  3573. h->long_ref[ mmco[i].long_index ]->long_ref=1;
  3574. h->long_ref_count++;
  3575. break;
  3576. case MMCO_LONG2UNUSED:
  3577. pic= remove_long(h, mmco[i].long_index);
  3578. if(pic)
  3579. unreference_pic(h, pic);
  3580. else if(s->avctx->debug&FF_DEBUG_MMCO)
  3581. av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_long() failure\n");
  3582. break;
  3583. case MMCO_LONG:
  3584. pic= remove_long(h, mmco[i].long_index);
  3585. if(pic) unreference_pic(h, pic);
  3586. h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr;
  3587. h->long_ref[ mmco[i].long_index ]->long_ref=1;
  3588. h->long_ref_count++;
  3589. current_is_long=1;
  3590. break;
  3591. case MMCO_SET_MAX_LONG:
  3592. assert(mmco[i].long_index <= 16);
  3593. // just remove the long term which index is greater than new max
  3594. for(j = mmco[i].long_index; j<16; j++){
  3595. pic = remove_long(h, j);
  3596. if (pic) unreference_pic(h, pic);
  3597. }
  3598. break;
  3599. case MMCO_RESET:
  3600. while(h->short_ref_count){
  3601. pic= remove_short(h, h->short_ref[0]->frame_num);
  3602. unreference_pic(h, pic);
  3603. }
  3604. for(j = 0; j < 16; j++) {
  3605. pic= remove_long(h, j);
  3606. if(pic) unreference_pic(h, pic);
  3607. }
  3608. break;
  3609. default: assert(0);
  3610. }
  3611. }
  3612. if(!current_is_long){
  3613. pic= remove_short(h, s->current_picture_ptr->frame_num);
  3614. if(pic){
  3615. unreference_pic(h, pic);
  3616. av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
  3617. }
  3618. if(h->short_ref_count)
  3619. memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*));
  3620. h->short_ref[0]= s->current_picture_ptr;
  3621. h->short_ref[0]->long_ref=0;
  3622. h->short_ref_count++;
  3623. }
  3624. print_short_term(h);
  3625. print_long_term(h);
  3626. return 0;
  3627. }
  3628. static int decode_ref_pic_marking(H264Context *h){
  3629. MpegEncContext * const s = &h->s;
  3630. int i;
  3631. if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields
  3632. s->broken_link= get_bits1(&s->gb) -1;
  3633. h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx
  3634. if(h->mmco[0].long_index == -1)
  3635. h->mmco_index= 0;
  3636. else{
  3637. h->mmco[0].opcode= MMCO_LONG;
  3638. h->mmco_index= 1;
  3639. }
  3640. }else{
  3641. if(get_bits1(&s->gb)){ // adaptive_ref_pic_marking_mode_flag
  3642. for(i= 0; i<MAX_MMCO_COUNT; i++) {
  3643. MMCOOpcode opcode= get_ue_golomb(&s->gb);;
  3644. h->mmco[i].opcode= opcode;
  3645. if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){
  3646. 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
  3647. /* if(h->mmco[i].short_frame_num >= h->short_ref_count || h->short_ref[ h->mmco[i].short_frame_num ] == NULL){
  3648. av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco);
  3649. return -1;
  3650. }*/
  3651. }
  3652. if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){
  3653. h->mmco[i].long_index= get_ue_golomb(&s->gb);
  3654. 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){
  3655. av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode);
  3656. return -1;
  3657. }
  3658. }
  3659. if(opcode > MMCO_LONG){
  3660. av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode);
  3661. return -1;
  3662. }
  3663. if(opcode == MMCO_END)
  3664. break;
  3665. }
  3666. h->mmco_index= i;
  3667. }else{
  3668. assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count);
  3669. if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields
  3670. h->mmco[0].opcode= MMCO_SHORT2UNUSED;
  3671. h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num;
  3672. h->mmco_index= 1;
  3673. }else
  3674. h->mmco_index= 0;
  3675. }
  3676. }
  3677. return 0;
  3678. }
  3679. static int init_poc(H264Context *h){
  3680. MpegEncContext * const s = &h->s;
  3681. const int max_frame_num= 1<<h->sps.log2_max_frame_num;
  3682. int field_poc[2];
  3683. if(h->nal_unit_type == NAL_IDR_SLICE){
  3684. h->frame_num_offset= 0;
  3685. }else{
  3686. if(h->frame_num < h->prev_frame_num)
  3687. h->frame_num_offset= h->prev_frame_num_offset + max_frame_num;
  3688. else
  3689. h->frame_num_offset= h->prev_frame_num_offset;
  3690. }
  3691. if(h->sps.poc_type==0){
  3692. const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb;
  3693. if(h->nal_unit_type == NAL_IDR_SLICE){
  3694. h->prev_poc_msb=
  3695. h->prev_poc_lsb= 0;
  3696. }
  3697. if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2)
  3698. h->poc_msb = h->prev_poc_msb + max_poc_lsb;
  3699. else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2)
  3700. h->poc_msb = h->prev_poc_msb - max_poc_lsb;
  3701. else
  3702. h->poc_msb = h->prev_poc_msb;
  3703. //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb);
  3704. field_poc[0] =
  3705. field_poc[1] = h->poc_msb + h->poc_lsb;
  3706. if(s->picture_structure == PICT_FRAME)
  3707. field_poc[1] += h->delta_poc_bottom;
  3708. }else if(h->sps.poc_type==1){
  3709. int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
  3710. int i;
  3711. if(h->sps.poc_cycle_length != 0)
  3712. abs_frame_num = h->frame_num_offset + h->frame_num;
  3713. else
  3714. abs_frame_num = 0;
  3715. if(h->nal_ref_idc==0 && abs_frame_num > 0)
  3716. abs_frame_num--;
  3717. expected_delta_per_poc_cycle = 0;
  3718. for(i=0; i < h->sps.poc_cycle_length; i++)
  3719. expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse
  3720. if(abs_frame_num > 0){
  3721. int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length;
  3722. int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length;
  3723. expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
  3724. for(i = 0; i <= frame_num_in_poc_cycle; i++)
  3725. expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ];
  3726. } else
  3727. expectedpoc = 0;
  3728. if(h->nal_ref_idc == 0)
  3729. expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic;
  3730. field_poc[0] = expectedpoc + h->delta_poc[0];
  3731. field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field;
  3732. if(s->picture_structure == PICT_FRAME)
  3733. field_poc[1] += h->delta_poc[1];
  3734. }else{
  3735. int poc;
  3736. if(h->nal_unit_type == NAL_IDR_SLICE){
  3737. poc= 0;
  3738. }else{
  3739. if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num);
  3740. else poc= 2*(h->frame_num_offset + h->frame_num) - 1;
  3741. }
  3742. field_poc[0]= poc;
  3743. field_poc[1]= poc;
  3744. }
  3745. if(s->picture_structure != PICT_BOTTOM_FIELD)
  3746. s->current_picture_ptr->field_poc[0]= field_poc[0];
  3747. if(s->picture_structure != PICT_TOP_FIELD)
  3748. s->current_picture_ptr->field_poc[1]= field_poc[1];
  3749. if(s->picture_structure == PICT_FRAME) // FIXME field pix?
  3750. s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]);
  3751. return 0;
  3752. }
  3753. /**
  3754. * decodes a slice header.
  3755. * this will allso call MPV_common_init() and frame_start() as needed
  3756. */
  3757. static int decode_slice_header(H264Context *h){
  3758. MpegEncContext * const s = &h->s;
  3759. int first_mb_in_slice, pps_id;
  3760. int num_ref_idx_active_override_flag;
  3761. static const uint8_t slice_type_map[5]= {P_TYPE, B_TYPE, I_TYPE, SP_TYPE, SI_TYPE};
  3762. int slice_type;
  3763. int default_ref_list_done = 0;
  3764. s->current_picture.reference= h->nal_ref_idc != 0;
  3765. s->dropable= h->nal_ref_idc == 0;
  3766. first_mb_in_slice= get_ue_golomb(&s->gb);
  3767. slice_type= get_ue_golomb(&s->gb);
  3768. if(slice_type > 9){
  3769. 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);
  3770. return -1;
  3771. }
  3772. if(slice_type > 4){
  3773. slice_type -= 5;
  3774. h->slice_type_fixed=1;
  3775. }else
  3776. h->slice_type_fixed=0;
  3777. slice_type= slice_type_map[ slice_type ];
  3778. if (slice_type == I_TYPE
  3779. || (h->slice_num != 0 && slice_type == h->slice_type) ) {
  3780. default_ref_list_done = 1;
  3781. }
  3782. h->slice_type= slice_type;
  3783. s->pict_type= h->slice_type; // to make a few old func happy, it's wrong though
  3784. pps_id= get_ue_golomb(&s->gb);
  3785. if(pps_id>255){
  3786. av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");
  3787. return -1;
  3788. }
  3789. h->pps= h->pps_buffer[pps_id];
  3790. if(h->pps.slice_group_count == 0){
  3791. av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n");
  3792. return -1;
  3793. }
  3794. h->sps= h->sps_buffer[ h->pps.sps_id ];
  3795. if(h->sps.log2_max_frame_num == 0){
  3796. av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n");
  3797. return -1;
  3798. }
  3799. if(h->dequant_coeff_pps != pps_id){
  3800. h->dequant_coeff_pps = pps_id;
  3801. init_dequant_tables(h);
  3802. }
  3803. s->mb_width= h->sps.mb_width;
  3804. s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);
  3805. h->b_stride= s->mb_width*4;
  3806. h->b8_stride= s->mb_width*2;
  3807. s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right );
  3808. if(h->sps.frame_mbs_only_flag)
  3809. s->height= 16*s->mb_height - 2*(h->sps.crop_top + h->sps.crop_bottom);
  3810. else
  3811. s->height= 16*s->mb_height - 4*(h->sps.crop_top + h->sps.crop_bottom); //FIXME recheck
  3812. if (s->context_initialized
  3813. && ( s->width != s->avctx->width || s->height != s->avctx->height)) {
  3814. free_tables(h);
  3815. MPV_common_end(s);
  3816. }
  3817. if (!s->context_initialized) {
  3818. if (MPV_common_init(s) < 0)
  3819. return -1;
  3820. if(s->dsp.h264_idct_add == ff_h264_idct_add_c){ //FIXME little ugly
  3821. memcpy(h->zigzag_scan, zigzag_scan, 16*sizeof(uint8_t));
  3822. memcpy(h-> field_scan, field_scan, 16*sizeof(uint8_t));
  3823. }else{
  3824. int i;
  3825. for(i=0; i<16; i++){
  3826. #define T(x) (x>>2) | ((x<<2) & 0xF)
  3827. h->zigzag_scan[i] = T(zigzag_scan[i]);
  3828. h-> field_scan[i] = T( field_scan[i]);
  3829. #undef T
  3830. }
  3831. }
  3832. if(s->dsp.h264_idct8_add == ff_h264_idct8_add_c){
  3833. memcpy(h->zigzag_scan8x8, zigzag_scan8x8, 64*sizeof(uint8_t));
  3834. memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t));
  3835. }else{
  3836. int i;
  3837. for(i=0; i<64; i++){
  3838. #define T(x) (x>>3) | ((x&7)<<3)
  3839. h->zigzag_scan8x8[i] = T(zigzag_scan8x8[i]);
  3840. h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]);
  3841. #undef T
  3842. }
  3843. }
  3844. if(h->sps.transform_bypass){ //FIXME same ugly
  3845. h->zigzag_scan_q0 = zigzag_scan;
  3846. h->field_scan_q0 = field_scan;
  3847. h->zigzag_scan8x8_q0 = zigzag_scan8x8;
  3848. h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc;
  3849. }else{
  3850. h->zigzag_scan_q0 = h->zigzag_scan;
  3851. h->field_scan_q0 = h->field_scan;
  3852. h->zigzag_scan8x8_q0 = h->zigzag_scan8x8;
  3853. h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc;
  3854. }
  3855. alloc_tables(h);
  3856. s->avctx->width = s->width;
  3857. s->avctx->height = s->height;
  3858. s->avctx->sample_aspect_ratio= h->sps.sar;
  3859. if(!s->avctx->sample_aspect_ratio.den)
  3860. s->avctx->sample_aspect_ratio.den = 1;
  3861. if(h->sps.timing_info_present_flag){
  3862. s->avctx->time_base= (AVRational){h->sps.num_units_in_tick * 2, h->sps.time_scale};
  3863. if(h->x264_build > 0 && h->x264_build < 44)
  3864. s->avctx->time_base.den *= 2;
  3865. av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,
  3866. s->avctx->time_base.num, s->avctx->time_base.den, 1<<30);
  3867. }
  3868. }
  3869. if(h->slice_num == 0){
  3870. if(frame_start(h) < 0)
  3871. return -1;
  3872. }
  3873. s->current_picture_ptr->frame_num= //FIXME frame_num cleanup
  3874. h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num);
  3875. h->mb_aff_frame = 0;
  3876. if(h->sps.frame_mbs_only_flag){
  3877. s->picture_structure= PICT_FRAME;
  3878. }else{
  3879. if(get_bits1(&s->gb)) { //field_pic_flag
  3880. s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag
  3881. } else {
  3882. s->picture_structure= PICT_FRAME;
  3883. first_mb_in_slice <<= h->sps.mb_aff;
  3884. h->mb_aff_frame = h->sps.mb_aff;
  3885. }
  3886. }
  3887. s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width;
  3888. s->resync_mb_y = s->mb_y = first_mb_in_slice / s->mb_width;
  3889. if(s->mb_y >= s->mb_height){
  3890. return -1;
  3891. }
  3892. if(s->picture_structure==PICT_FRAME){
  3893. h->curr_pic_num= h->frame_num;
  3894. h->max_pic_num= 1<< h->sps.log2_max_frame_num;
  3895. }else{
  3896. h->curr_pic_num= 2*h->frame_num;
  3897. h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1);
  3898. }
  3899. if(h->nal_unit_type == NAL_IDR_SLICE){
  3900. get_ue_golomb(&s->gb); /* idr_pic_id */
  3901. }
  3902. if(h->sps.poc_type==0){
  3903. h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb);
  3904. if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){
  3905. h->delta_poc_bottom= get_se_golomb(&s->gb);
  3906. }
  3907. }
  3908. if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){
  3909. h->delta_poc[0]= get_se_golomb(&s->gb);
  3910. if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME)
  3911. h->delta_poc[1]= get_se_golomb(&s->gb);
  3912. }
  3913. init_poc(h);
  3914. if(h->pps.redundant_pic_cnt_present){
  3915. h->redundant_pic_count= get_ue_golomb(&s->gb);
  3916. }
  3917. //set defaults, might be overriden a few line later
  3918. h->ref_count[0]= h->pps.ref_count[0];
  3919. h->ref_count[1]= h->pps.ref_count[1];
  3920. if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){
  3921. if(h->slice_type == B_TYPE){
  3922. h->direct_spatial_mv_pred= get_bits1(&s->gb);
  3923. }
  3924. num_ref_idx_active_override_flag= get_bits1(&s->gb);
  3925. if(num_ref_idx_active_override_flag){
  3926. h->ref_count[0]= get_ue_golomb(&s->gb) + 1;
  3927. if(h->slice_type==B_TYPE)
  3928. h->ref_count[1]= get_ue_golomb(&s->gb) + 1;
  3929. if(h->ref_count[0] > 32 || h->ref_count[1] > 32){
  3930. av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");
  3931. return -1;
  3932. }
  3933. }
  3934. }
  3935. if(!default_ref_list_done){
  3936. fill_default_ref_list(h);
  3937. }
  3938. if(decode_ref_pic_list_reordering(h) < 0)
  3939. return -1;
  3940. if( (h->pps.weighted_pred && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE ))
  3941. || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) )
  3942. pred_weight_table(h);
  3943. else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE)
  3944. implicit_weight_table(h);
  3945. else
  3946. h->use_weight = 0;
  3947. if(s->current_picture.reference)
  3948. decode_ref_pic_marking(h);
  3949. if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE && h->pps.cabac )
  3950. h->cabac_init_idc = get_ue_golomb(&s->gb);
  3951. h->last_qscale_diff = 0;
  3952. s->qscale = h->pps.init_qp + get_se_golomb(&s->gb);
  3953. if(s->qscale<0 || s->qscale>51){
  3954. av_log(s->avctx, AV_LOG_ERROR, "QP %d out of range\n", s->qscale);
  3955. return -1;
  3956. }
  3957. h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale);
  3958. //FIXME qscale / qp ... stuff
  3959. if(h->slice_type == SP_TYPE){
  3960. get_bits1(&s->gb); /* sp_for_switch_flag */
  3961. }
  3962. if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){
  3963. get_se_golomb(&s->gb); /* slice_qs_delta */
  3964. }
  3965. h->deblocking_filter = 1;
  3966. h->slice_alpha_c0_offset = 0;
  3967. h->slice_beta_offset = 0;
  3968. if( h->pps.deblocking_filter_parameters_present ) {
  3969. h->deblocking_filter= get_ue_golomb(&s->gb);
  3970. if(h->deblocking_filter < 2)
  3971. h->deblocking_filter^= 1; // 1<->0
  3972. if( h->deblocking_filter ) {
  3973. h->slice_alpha_c0_offset = get_se_golomb(&s->gb) << 1;
  3974. h->slice_beta_offset = get_se_golomb(&s->gb) << 1;
  3975. }
  3976. }
  3977. if( s->avctx->skip_loop_filter >= AVDISCARD_ALL
  3978. ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type != I_TYPE)
  3979. ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && h->slice_type == B_TYPE)
  3980. ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
  3981. h->deblocking_filter= 0;
  3982. #if 0 //FMO
  3983. if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5)
  3984. slice_group_change_cycle= get_bits(&s->gb, ?);
  3985. #endif
  3986. h->slice_num++;
  3987. if(s->avctx->debug&FF_DEBUG_PICT_INFO){
  3988. 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",
  3989. h->slice_num,
  3990. (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"),
  3991. first_mb_in_slice,
  3992. av_get_pict_type_char(h->slice_type),
  3993. pps_id, h->frame_num,
  3994. s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1],
  3995. h->ref_count[0], h->ref_count[1],
  3996. s->qscale,
  3997. h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2,
  3998. h->use_weight,
  3999. h->use_weight==1 && h->use_weight_chroma ? "c" : ""
  4000. );
  4001. }
  4002. return 0;
  4003. }
  4004. /**
  4005. *
  4006. */
  4007. static inline int get_level_prefix(GetBitContext *gb){
  4008. unsigned int buf;
  4009. int log;
  4010. OPEN_READER(re, gb);
  4011. UPDATE_CACHE(re, gb);
  4012. buf=GET_CACHE(re, gb);
  4013. log= 32 - av_log2(buf);
  4014. #ifdef TRACE
  4015. print_bin(buf>>(32-log), log);
  4016. 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__);
  4017. #endif
  4018. LAST_SKIP_BITS(re, gb, log);
  4019. CLOSE_READER(re, gb);
  4020. return log-1;
  4021. }
  4022. static inline int get_dct8x8_allowed(H264Context *h){
  4023. int i;
  4024. for(i=0; i<4; i++){
  4025. if(!IS_SUB_8X8(h->sub_mb_type[i])
  4026. || (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i])))
  4027. return 0;
  4028. }
  4029. return 1;
  4030. }
  4031. /**
  4032. * decodes a residual block.
  4033. * @param n block index
  4034. * @param scantable scantable
  4035. * @param max_coeff number of coefficients in the block
  4036. * @return <0 if an error occured
  4037. */
  4038. static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
  4039. MpegEncContext * const s = &h->s;
  4040. 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};
  4041. int level[16];
  4042. int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before;
  4043. //FIXME put trailing_onex into the context
  4044. if(n == CHROMA_DC_BLOCK_INDEX){
  4045. coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
  4046. total_coeff= coeff_token>>2;
  4047. }else{
  4048. if(n == LUMA_DC_BLOCK_INDEX){
  4049. total_coeff= pred_non_zero_count(h, 0);
  4050. coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
  4051. total_coeff= coeff_token>>2;
  4052. }else{
  4053. total_coeff= pred_non_zero_count(h, n);
  4054. coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
  4055. total_coeff= coeff_token>>2;
  4056. h->non_zero_count_cache[ scan8[n] ]= total_coeff;
  4057. }
  4058. }
  4059. //FIXME set last_non_zero?
  4060. if(total_coeff==0)
  4061. return 0;
  4062. trailing_ones= coeff_token&3;
  4063. tprintf("trailing:%d, total:%d\n", trailing_ones, total_coeff);
  4064. assert(total_coeff<=16);
  4065. for(i=0; i<trailing_ones; i++){
  4066. level[i]= 1 - 2*get_bits1(gb);
  4067. }
  4068. if(i<total_coeff) {
  4069. int level_code, mask;
  4070. int suffix_length = total_coeff > 10 && trailing_ones < 3;
  4071. int prefix= get_level_prefix(gb);
  4072. //first coefficient has suffix_length equal to 0 or 1
  4073. if(prefix<14){ //FIXME try to build a large unified VLC table for all this
  4074. if(suffix_length)
  4075. level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
  4076. else
  4077. level_code= (prefix<<suffix_length); //part
  4078. }else if(prefix==14){
  4079. if(suffix_length)
  4080. level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
  4081. else
  4082. level_code= prefix + get_bits(gb, 4); //part
  4083. }else if(prefix==15){
  4084. level_code= (prefix<<suffix_length) + get_bits(gb, 12); //part
  4085. if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense
  4086. }else{
  4087. av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y);
  4088. return -1;
  4089. }
  4090. if(trailing_ones < 3) level_code += 2;
  4091. suffix_length = 1;
  4092. if(level_code > 5)
  4093. suffix_length++;
  4094. mask= -(level_code&1);
  4095. level[i]= (((2+level_code)>>1) ^ mask) - mask;
  4096. i++;
  4097. //remaining coefficients have suffix_length > 0
  4098. for(;i<total_coeff;i++) {
  4099. static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX };
  4100. prefix = get_level_prefix(gb);
  4101. if(prefix<15){
  4102. level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
  4103. }else if(prefix==15){
  4104. level_code = (prefix<<suffix_length) + get_bits(gb, 12);
  4105. }else{
  4106. av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y);
  4107. return -1;
  4108. }
  4109. mask= -(level_code&1);
  4110. level[i]= (((2+level_code)>>1) ^ mask) - mask;
  4111. if(level_code > suffix_limit[suffix_length])
  4112. suffix_length++;
  4113. }
  4114. }
  4115. if(total_coeff == max_coeff)
  4116. zeros_left=0;
  4117. else{
  4118. if(n == CHROMA_DC_BLOCK_INDEX)
  4119. zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
  4120. else
  4121. zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1);
  4122. }
  4123. coeff_num = zeros_left + total_coeff - 1;
  4124. j = scantable[coeff_num];
  4125. if(n > 24){
  4126. block[j] = level[0];
  4127. for(i=1;i<total_coeff;i++) {
  4128. if(zeros_left <= 0)
  4129. run_before = 0;
  4130. else if(zeros_left < 7){
  4131. run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);
  4132. }else{
  4133. run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
  4134. }
  4135. zeros_left -= run_before;
  4136. coeff_num -= 1 + run_before;
  4137. j= scantable[ coeff_num ];
  4138. block[j]= level[i];
  4139. }
  4140. }else{
  4141. block[j] = (level[0] * qmul[j] + 32)>>6;
  4142. for(i=1;i<total_coeff;i++) {
  4143. if(zeros_left <= 0)
  4144. run_before = 0;
  4145. else if(zeros_left < 7){
  4146. run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);
  4147. }else{
  4148. run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
  4149. }
  4150. zeros_left -= run_before;
  4151. coeff_num -= 1 + run_before;
  4152. j= scantable[ coeff_num ];
  4153. block[j]= (level[i] * qmul[j] + 32)>>6;
  4154. }
  4155. }
  4156. if(zeros_left<0){
  4157. av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);
  4158. return -1;
  4159. }
  4160. return 0;
  4161. }
  4162. /**
  4163. * decodes a P_SKIP or B_SKIP macroblock
  4164. */
  4165. static void decode_mb_skip(H264Context *h){
  4166. MpegEncContext * const s = &h->s;
  4167. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  4168. int mb_type=0;
  4169. memset(h->non_zero_count[mb_xy], 0, 16);
  4170. memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui
  4171. if(h->mb_aff_frame && s->mb_skip_run==0 && (s->mb_y&1)==0){
  4172. h->mb_field_decoding_flag= get_bits1(&s->gb);
  4173. }
  4174. if(h->mb_field_decoding_flag)
  4175. mb_type|= MB_TYPE_INTERLACED;
  4176. if( h->slice_type == B_TYPE )
  4177. {
  4178. // just for fill_caches. pred_direct_motion will set the real mb_type
  4179. mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP;
  4180. fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ...
  4181. pred_direct_motion(h, &mb_type);
  4182. if(h->pps.cabac){
  4183. fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
  4184. fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
  4185. }
  4186. }
  4187. else
  4188. {
  4189. int mx, my;
  4190. mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP;
  4191. fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ...
  4192. pred_pskip_motion(h, &mx, &my);
  4193. fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);
  4194. fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4);
  4195. if(h->pps.cabac)
  4196. fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
  4197. }
  4198. write_back_motion(h, mb_type);
  4199. s->current_picture.mb_type[mb_xy]= mb_type|MB_TYPE_SKIP;
  4200. s->current_picture.qscale_table[mb_xy]= s->qscale;
  4201. h->slice_table[ mb_xy ]= h->slice_num;
  4202. h->prev_mb_skipped= 1;
  4203. }
  4204. /**
  4205. * decodes a macroblock
  4206. * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
  4207. */
  4208. static int decode_mb_cavlc(H264Context *h){
  4209. MpegEncContext * const s = &h->s;
  4210. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  4211. int mb_type, partition_count, cbp;
  4212. int dct8x8_allowed= h->pps.transform_8x8_mode;
  4213. s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong?
  4214. tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
  4215. cbp = 0; /* avoid warning. FIXME: find a solution without slowing
  4216. down the code */
  4217. if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){
  4218. if(s->mb_skip_run==-1)
  4219. s->mb_skip_run= get_ue_golomb(&s->gb);
  4220. if (s->mb_skip_run--) {
  4221. decode_mb_skip(h);
  4222. return 0;
  4223. }
  4224. }
  4225. if(h->mb_aff_frame){
  4226. if ( ((s->mb_y&1) == 0) || h->prev_mb_skipped)
  4227. h->mb_field_decoding_flag = get_bits1(&s->gb);
  4228. }else
  4229. h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME);
  4230. h->prev_mb_skipped= 0;
  4231. mb_type= get_ue_golomb(&s->gb);
  4232. if(h->slice_type == B_TYPE){
  4233. if(mb_type < 23){
  4234. partition_count= b_mb_type_info[mb_type].partition_count;
  4235. mb_type= b_mb_type_info[mb_type].type;
  4236. }else{
  4237. mb_type -= 23;
  4238. goto decode_intra_mb;
  4239. }
  4240. }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){
  4241. if(mb_type < 5){
  4242. partition_count= p_mb_type_info[mb_type].partition_count;
  4243. mb_type= p_mb_type_info[mb_type].type;
  4244. }else{
  4245. mb_type -= 5;
  4246. goto decode_intra_mb;
  4247. }
  4248. }else{
  4249. assert(h->slice_type == I_TYPE);
  4250. decode_intra_mb:
  4251. if(mb_type > 25){
  4252. 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);
  4253. return -1;
  4254. }
  4255. partition_count=0;
  4256. cbp= i_mb_type_info[mb_type].cbp;
  4257. h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
  4258. mb_type= i_mb_type_info[mb_type].type;
  4259. }
  4260. if(h->mb_field_decoding_flag)
  4261. mb_type |= MB_TYPE_INTERLACED;
  4262. h->slice_table[ mb_xy ]= h->slice_num;
  4263. if(IS_INTRA_PCM(mb_type)){
  4264. unsigned int x, y;
  4265. // we assume these blocks are very rare so we dont optimize it
  4266. align_get_bits(&s->gb);
  4267. // The pixels are stored in the same order as levels in h->mb array.
  4268. for(y=0; y<16; y++){
  4269. const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3);
  4270. for(x=0; x<16; x++){
  4271. tprintf("LUMA ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8));
  4272. h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8);
  4273. }
  4274. }
  4275. for(y=0; y<8; y++){
  4276. const int index= 256 + 4*(y&3) + 32*(y>>2);
  4277. for(x=0; x<8; x++){
  4278. tprintf("CHROMA U ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8));
  4279. h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8);
  4280. }
  4281. }
  4282. for(y=0; y<8; y++){
  4283. const int index= 256 + 64 + 4*(y&3) + 32*(y>>2);
  4284. for(x=0; x<8; x++){
  4285. tprintf("CHROMA V ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8));
  4286. h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8);
  4287. }
  4288. }
  4289. // In deblocking, the quantizer is 0
  4290. s->current_picture.qscale_table[mb_xy]= 0;
  4291. h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, 0);
  4292. // All coeffs are present
  4293. memset(h->non_zero_count[mb_xy], 16, 16);
  4294. s->current_picture.mb_type[mb_xy]= mb_type;
  4295. return 0;
  4296. }
  4297. fill_caches(h, mb_type, 0);
  4298. //mb_pred
  4299. if(IS_INTRA(mb_type)){
  4300. // init_top_left_availability(h);
  4301. if(IS_INTRA4x4(mb_type)){
  4302. int i;
  4303. int di = 1;
  4304. if(dct8x8_allowed && get_bits1(&s->gb)){
  4305. mb_type |= MB_TYPE_8x8DCT;
  4306. di = 4;
  4307. }
  4308. // fill_intra4x4_pred_table(h);
  4309. for(i=0; i<16; i+=di){
  4310. const int mode_coded= !get_bits1(&s->gb);
  4311. const int predicted_mode= pred_intra_mode(h, i);
  4312. int mode;
  4313. if(mode_coded){
  4314. const int rem_mode= get_bits(&s->gb, 3);
  4315. if(rem_mode<predicted_mode)
  4316. mode= rem_mode;
  4317. else
  4318. mode= rem_mode + 1;
  4319. }else{
  4320. mode= predicted_mode;
  4321. }
  4322. if(di==4)
  4323. fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
  4324. else
  4325. h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
  4326. }
  4327. write_back_intra_pred_mode(h);
  4328. if( check_intra4x4_pred_mode(h) < 0)
  4329. return -1;
  4330. }else{
  4331. h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode);
  4332. if(h->intra16x16_pred_mode < 0)
  4333. return -1;
  4334. }
  4335. h->chroma_pred_mode= get_ue_golomb(&s->gb);
  4336. h->chroma_pred_mode= check_intra_pred_mode(h, h->chroma_pred_mode);
  4337. if(h->chroma_pred_mode < 0)
  4338. return -1;
  4339. }else if(partition_count==4){
  4340. int i, j, sub_partition_count[4], list, ref[2][4];
  4341. if(h->slice_type == B_TYPE){
  4342. for(i=0; i<4; i++){
  4343. h->sub_mb_type[i]= get_ue_golomb(&s->gb);
  4344. if(h->sub_mb_type[i] >=13){
  4345. 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);
  4346. return -1;
  4347. }
  4348. sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
  4349. h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
  4350. }
  4351. if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1])
  4352. || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {
  4353. pred_direct_motion(h, &mb_type);
  4354. h->ref_cache[0][scan8[4]] =
  4355. h->ref_cache[1][scan8[4]] =
  4356. h->ref_cache[0][scan8[12]] =
  4357. h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
  4358. }
  4359. }else{
  4360. assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ?
  4361. for(i=0; i<4; i++){
  4362. h->sub_mb_type[i]= get_ue_golomb(&s->gb);
  4363. if(h->sub_mb_type[i] >=4){
  4364. 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);
  4365. return -1;
  4366. }
  4367. sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
  4368. h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
  4369. }
  4370. }
  4371. for(list=0; list<2; list++){
  4372. int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
  4373. if(ref_count == 0) continue;
  4374. if (h->mb_aff_frame && h->mb_field_decoding_flag) {
  4375. ref_count <<= 1;
  4376. }
  4377. for(i=0; i<4; i++){
  4378. if(IS_DIRECT(h->sub_mb_type[i])) continue;
  4379. if(IS_DIR(h->sub_mb_type[i], 0, list)){
  4380. ref[list][i] = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip?
  4381. }else{
  4382. //FIXME
  4383. ref[list][i] = -1;
  4384. }
  4385. }
  4386. }
  4387. if(dct8x8_allowed)
  4388. dct8x8_allowed = get_dct8x8_allowed(h);
  4389. for(list=0; list<2; list++){
  4390. const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
  4391. if(ref_count == 0) continue;
  4392. for(i=0; i<4; i++){
  4393. if(IS_DIRECT(h->sub_mb_type[i])) {
  4394. h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
  4395. continue;
  4396. }
  4397. h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]=
  4398. h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
  4399. if(IS_DIR(h->sub_mb_type[i], 0, list)){
  4400. const int sub_mb_type= h->sub_mb_type[i];
  4401. const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
  4402. for(j=0; j<sub_partition_count[i]; j++){
  4403. int mx, my;
  4404. const int index= 4*i + block_width*j;
  4405. int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
  4406. pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
  4407. mx += get_se_golomb(&s->gb);
  4408. my += get_se_golomb(&s->gb);
  4409. tprintf("final mv:%d %d\n", mx, my);
  4410. if(IS_SUB_8X8(sub_mb_type)){
  4411. mv_cache[ 0 ][0]= mv_cache[ 1 ][0]=
  4412. mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
  4413. mv_cache[ 0 ][1]= mv_cache[ 1 ][1]=
  4414. mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
  4415. }else if(IS_SUB_8X4(sub_mb_type)){
  4416. mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx;
  4417. mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my;
  4418. }else if(IS_SUB_4X8(sub_mb_type)){
  4419. mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx;
  4420. mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my;
  4421. }else{
  4422. assert(IS_SUB_4X4(sub_mb_type));
  4423. mv_cache[ 0 ][0]= mx;
  4424. mv_cache[ 0 ][1]= my;
  4425. }
  4426. }
  4427. }else{
  4428. uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
  4429. p[0] = p[1]=
  4430. p[8] = p[9]= 0;
  4431. }
  4432. }
  4433. }
  4434. }else if(IS_DIRECT(mb_type)){
  4435. pred_direct_motion(h, &mb_type);
  4436. dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
  4437. }else{
  4438. int list, mx, my, i;
  4439. //FIXME we should set ref_idx_l? to 0 if we use that later ...
  4440. if(IS_16X16(mb_type)){
  4441. for(list=0; list<2; list++){
  4442. if(h->ref_count[list]>0){
  4443. if(IS_DIR(mb_type, 0, list)){
  4444. const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
  4445. fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
  4446. }else
  4447. fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (LIST_NOT_USED&0xFF), 1);
  4448. }
  4449. }
  4450. for(list=0; list<2; list++){
  4451. if(IS_DIR(mb_type, 0, list)){
  4452. pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
  4453. mx += get_se_golomb(&s->gb);
  4454. my += get_se_golomb(&s->gb);
  4455. tprintf("final mv:%d %d\n", mx, my);
  4456. fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
  4457. }else
  4458. fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
  4459. }
  4460. }
  4461. else if(IS_16X8(mb_type)){
  4462. for(list=0; list<2; list++){
  4463. if(h->ref_count[list]>0){
  4464. for(i=0; i<2; i++){
  4465. if(IS_DIR(mb_type, i, list)){
  4466. const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
  4467. fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
  4468. }else
  4469. fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
  4470. }
  4471. }
  4472. }
  4473. for(list=0; list<2; list++){
  4474. for(i=0; i<2; i++){
  4475. if(IS_DIR(mb_type, i, list)){
  4476. pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
  4477. mx += get_se_golomb(&s->gb);
  4478. my += get_se_golomb(&s->gb);
  4479. tprintf("final mv:%d %d\n", mx, my);
  4480. fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
  4481. }else
  4482. fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
  4483. }
  4484. }
  4485. }else{
  4486. assert(IS_8X16(mb_type));
  4487. for(list=0; list<2; list++){
  4488. if(h->ref_count[list]>0){
  4489. for(i=0; i<2; i++){
  4490. if(IS_DIR(mb_type, i, list)){ //FIXME optimize
  4491. const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
  4492. fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
  4493. }else
  4494. fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
  4495. }
  4496. }
  4497. }
  4498. for(list=0; list<2; list++){
  4499. for(i=0; i<2; i++){
  4500. if(IS_DIR(mb_type, i, list)){
  4501. pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
  4502. mx += get_se_golomb(&s->gb);
  4503. my += get_se_golomb(&s->gb);
  4504. tprintf("final mv:%d %d\n", mx, my);
  4505. fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
  4506. }else
  4507. fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
  4508. }
  4509. }
  4510. }
  4511. }
  4512. if(IS_INTER(mb_type))
  4513. write_back_motion(h, mb_type);
  4514. if(!IS_INTRA16x16(mb_type)){
  4515. cbp= get_ue_golomb(&s->gb);
  4516. if(cbp > 47){
  4517. av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%d) at %d %d\n", cbp, s->mb_x, s->mb_y);
  4518. return -1;
  4519. }
  4520. if(IS_INTRA4x4(mb_type))
  4521. cbp= golomb_to_intra4x4_cbp[cbp];
  4522. else
  4523. cbp= golomb_to_inter_cbp[cbp];
  4524. }
  4525. if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
  4526. if(get_bits1(&s->gb))
  4527. mb_type |= MB_TYPE_8x8DCT;
  4528. }
  4529. s->current_picture.mb_type[mb_xy]= mb_type;
  4530. if(cbp || IS_INTRA16x16(mb_type)){
  4531. int i8x8, i4x4, chroma_idx;
  4532. int chroma_qp, dquant;
  4533. GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
  4534. const uint8_t *scan, *scan8x8, *dc_scan;
  4535. // fill_non_zero_count_cache(h);
  4536. if(IS_INTERLACED(mb_type)){
  4537. scan= s->qscale ? h->field_scan : h->field_scan_q0;
  4538. dc_scan= luma_dc_field_scan;
  4539. }else{
  4540. scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
  4541. dc_scan= luma_dc_zigzag_scan;
  4542. }
  4543. scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
  4544. dquant= get_se_golomb(&s->gb);
  4545. if( dquant > 25 || dquant < -26 ){
  4546. av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
  4547. return -1;
  4548. }
  4549. s->qscale += dquant;
  4550. if(((unsigned)s->qscale) > 51){
  4551. if(s->qscale<0) s->qscale+= 52;
  4552. else s->qscale-= 52;
  4553. }
  4554. h->chroma_qp= chroma_qp= get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale);
  4555. if(IS_INTRA16x16(mb_type)){
  4556. if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){
  4557. return -1; //FIXME continue if partitioned and other return -1 too
  4558. }
  4559. assert((cbp&15) == 0 || (cbp&15) == 15);
  4560. if(cbp&15){
  4561. for(i8x8=0; i8x8<4; i8x8++){
  4562. for(i4x4=0; i4x4<4; i4x4++){
  4563. const int index= i4x4 + 4*i8x8;
  4564. if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){
  4565. return -1;
  4566. }
  4567. }
  4568. }
  4569. }else{
  4570. fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
  4571. }
  4572. }else{
  4573. for(i8x8=0; i8x8<4; i8x8++){
  4574. if(cbp & (1<<i8x8)){
  4575. if(IS_8x8DCT(mb_type)){
  4576. DCTELEM *buf = &h->mb[64*i8x8];
  4577. uint8_t *nnz;
  4578. for(i4x4=0; i4x4<4; i4x4++){
  4579. if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4,
  4580. h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 )
  4581. return -1;
  4582. }
  4583. nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
  4584. nnz[0] += nnz[1] + nnz[8] + nnz[9];
  4585. }else{
  4586. for(i4x4=0; i4x4<4; i4x4++){
  4587. const int index= i4x4 + 4*i8x8;
  4588. if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){
  4589. return -1;
  4590. }
  4591. }
  4592. }
  4593. }else{
  4594. uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
  4595. nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
  4596. }
  4597. }
  4598. }
  4599. if(cbp&0x30){
  4600. for(chroma_idx=0; chroma_idx<2; chroma_idx++)
  4601. if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){
  4602. return -1;
  4603. }
  4604. }
  4605. if(cbp&0x20){
  4606. for(chroma_idx=0; chroma_idx<2; chroma_idx++){
  4607. for(i4x4=0; i4x4<4; i4x4++){
  4608. const int index= 16 + 4*chroma_idx + i4x4;
  4609. 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){
  4610. return -1;
  4611. }
  4612. }
  4613. }
  4614. }else{
  4615. uint8_t * const nnz= &h->non_zero_count_cache[0];
  4616. nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
  4617. nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
  4618. }
  4619. }else{
  4620. uint8_t * const nnz= &h->non_zero_count_cache[0];
  4621. fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
  4622. nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
  4623. nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
  4624. }
  4625. s->current_picture.qscale_table[mb_xy]= s->qscale;
  4626. write_back_non_zero_count(h);
  4627. return 0;
  4628. }
  4629. static int decode_cabac_field_decoding_flag(H264Context *h) {
  4630. MpegEncContext * const s = &h->s;
  4631. const int mb_x = s->mb_x;
  4632. const int mb_y = s->mb_y & ~1;
  4633. const int mba_xy = mb_x - 1 + mb_y *s->mb_stride;
  4634. const int mbb_xy = mb_x + (mb_y-2)*s->mb_stride;
  4635. unsigned int ctx = 0;
  4636. if( h->slice_table[mba_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) {
  4637. ctx += 1;
  4638. }
  4639. if( h->slice_table[mbb_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) {
  4640. ctx += 1;
  4641. }
  4642. return get_cabac( &h->cabac, &h->cabac_state[70 + ctx] );
  4643. }
  4644. static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
  4645. uint8_t *state= &h->cabac_state[ctx_base];
  4646. int mb_type;
  4647. if(intra_slice){
  4648. MpegEncContext * const s = &h->s;
  4649. const int mba_xy = h->left_mb_xy[0];
  4650. const int mbb_xy = h->top_mb_xy;
  4651. int ctx=0;
  4652. if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) )
  4653. ctx++;
  4654. if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) )
  4655. ctx++;
  4656. if( get_cabac( &h->cabac, &state[ctx] ) == 0 )
  4657. return 0; /* I4x4 */
  4658. state += 2;
  4659. }else{
  4660. if( get_cabac( &h->cabac, &state[0] ) == 0 )
  4661. return 0; /* I4x4 */
  4662. }
  4663. if( get_cabac_terminate( &h->cabac ) )
  4664. return 25; /* PCM */
  4665. mb_type = 1; /* I16x16 */
  4666. mb_type += 12 * get_cabac( &h->cabac, &state[1] ); /* cbp_luma != 0 */
  4667. if( get_cabac( &h->cabac, &state[2] ) ) /* cbp_chroma */
  4668. mb_type += 4 + 4 * get_cabac( &h->cabac, &state[2+intra_slice] );
  4669. mb_type += 2 * get_cabac( &h->cabac, &state[3+intra_slice] );
  4670. mb_type += 1 * get_cabac( &h->cabac, &state[3+2*intra_slice] );
  4671. return mb_type;
  4672. }
  4673. static int decode_cabac_mb_type( H264Context *h ) {
  4674. MpegEncContext * const s = &h->s;
  4675. if( h->slice_type == I_TYPE ) {
  4676. return decode_cabac_intra_mb_type(h, 3, 1);
  4677. } else if( h->slice_type == P_TYPE ) {
  4678. if( get_cabac( &h->cabac, &h->cabac_state[14] ) == 0 ) {
  4679. /* P-type */
  4680. if( get_cabac( &h->cabac, &h->cabac_state[15] ) == 0 ) {
  4681. /* P_L0_D16x16, P_8x8 */
  4682. return 3 * get_cabac( &h->cabac, &h->cabac_state[16] );
  4683. } else {
  4684. /* P_L0_D8x16, P_L0_D16x8 */
  4685. return 2 - get_cabac( &h->cabac, &h->cabac_state[17] );
  4686. }
  4687. } else {
  4688. return decode_cabac_intra_mb_type(h, 17, 0) + 5;
  4689. }
  4690. } else if( h->slice_type == B_TYPE ) {
  4691. const int mba_xy = h->left_mb_xy[0];
  4692. const int mbb_xy = h->top_mb_xy;
  4693. int ctx = 0;
  4694. int bits;
  4695. if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )
  4696. ctx++;
  4697. if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) )
  4698. ctx++;
  4699. if( !get_cabac( &h->cabac, &h->cabac_state[27+ctx] ) )
  4700. return 0; /* B_Direct_16x16 */
  4701. if( !get_cabac( &h->cabac, &h->cabac_state[27+3] ) ) {
  4702. return 1 + get_cabac( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
  4703. }
  4704. bits = get_cabac( &h->cabac, &h->cabac_state[27+4] ) << 3;
  4705. bits|= get_cabac( &h->cabac, &h->cabac_state[27+5] ) << 2;
  4706. bits|= get_cabac( &h->cabac, &h->cabac_state[27+5] ) << 1;
  4707. bits|= get_cabac( &h->cabac, &h->cabac_state[27+5] );
  4708. if( bits < 8 )
  4709. return bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
  4710. else if( bits == 13 ) {
  4711. return decode_cabac_intra_mb_type(h, 32, 0) + 23;
  4712. } else if( bits == 14 )
  4713. return 11; /* B_L1_L0_8x16 */
  4714. else if( bits == 15 )
  4715. return 22; /* B_8x8 */
  4716. bits= ( bits<<1 ) | get_cabac( &h->cabac, &h->cabac_state[27+5] );
  4717. return bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
  4718. } else {
  4719. /* TODO SI/SP frames? */
  4720. return -1;
  4721. }
  4722. }
  4723. static int decode_cabac_mb_skip( H264Context *h) {
  4724. MpegEncContext * const s = &h->s;
  4725. const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
  4726. const int mba_xy = mb_xy - 1;
  4727. const int mbb_xy = mb_xy - s->mb_stride;
  4728. int ctx = 0;
  4729. if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
  4730. ctx++;
  4731. if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
  4732. ctx++;
  4733. if( h->slice_type == B_TYPE )
  4734. ctx += 13;
  4735. return get_cabac( &h->cabac, &h->cabac_state[11+ctx] );
  4736. }
  4737. static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
  4738. int mode = 0;
  4739. if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
  4740. return pred_mode;
  4741. mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
  4742. mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
  4743. mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
  4744. if( mode >= pred_mode )
  4745. return mode + 1;
  4746. else
  4747. return mode;
  4748. }
  4749. static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
  4750. const int mba_xy = h->left_mb_xy[0];
  4751. const int mbb_xy = h->top_mb_xy;
  4752. int ctx = 0;
  4753. /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
  4754. if( h->slice_table[mba_xy] == h->slice_num && h->chroma_pred_mode_table[mba_xy] != 0 )
  4755. ctx++;
  4756. if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )
  4757. ctx++;
  4758. if( get_cabac( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
  4759. return 0;
  4760. if( get_cabac( &h->cabac, &h->cabac_state[64+3] ) == 0 )
  4761. return 1;
  4762. if( get_cabac( &h->cabac, &h->cabac_state[64+3] ) == 0 )
  4763. return 2;
  4764. else
  4765. return 3;
  4766. }
  4767. static const uint8_t block_idx_x[16] = {
  4768. 0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
  4769. };
  4770. static const uint8_t block_idx_y[16] = {
  4771. 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
  4772. };
  4773. static const uint8_t block_idx_xy[4][4] = {
  4774. { 0, 2, 8, 10},
  4775. { 1, 3, 9, 11},
  4776. { 4, 6, 12, 14},
  4777. { 5, 7, 13, 15}
  4778. };
  4779. static int decode_cabac_mb_cbp_luma( H264Context *h) {
  4780. int cbp = 0;
  4781. int cbp_b = -1;
  4782. int i8x8;
  4783. if( h->slice_table[h->top_mb_xy] == h->slice_num ) {
  4784. cbp_b = h->top_cbp;
  4785. tprintf("cbp_b = top_cbp = %x\n", cbp_b);
  4786. }
  4787. for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
  4788. int cbp_a = -1;
  4789. int x, y;
  4790. int ctx = 0;
  4791. x = block_idx_x[4*i8x8];
  4792. y = block_idx_y[4*i8x8];
  4793. if( x > 0 )
  4794. cbp_a = cbp;
  4795. else if( h->slice_table[h->left_mb_xy[0]] == h->slice_num ) {
  4796. cbp_a = h->left_cbp;
  4797. tprintf("cbp_a = left_cbp = %x\n", cbp_a);
  4798. }
  4799. if( y > 0 )
  4800. cbp_b = cbp;
  4801. /* No need to test for skip as we put 0 for skip block */
  4802. /* No need to test for IPCM as we put 1 for IPCM block */
  4803. if( cbp_a >= 0 ) {
  4804. int i8x8a = block_idx_xy[(x-1)&0x03][y]/4;
  4805. if( ((cbp_a >> i8x8a)&0x01) == 0 )
  4806. ctx++;
  4807. }
  4808. if( cbp_b >= 0 ) {
  4809. int i8x8b = block_idx_xy[x][(y-1)&0x03]/4;
  4810. if( ((cbp_b >> i8x8b)&0x01) == 0 )
  4811. ctx += 2;
  4812. }
  4813. if( get_cabac( &h->cabac, &h->cabac_state[73 + ctx] ) ) {
  4814. cbp |= 1 << i8x8;
  4815. }
  4816. }
  4817. return cbp;
  4818. }
  4819. static int decode_cabac_mb_cbp_chroma( H264Context *h) {
  4820. int ctx;
  4821. int cbp_a, cbp_b;
  4822. cbp_a = (h->left_cbp>>4)&0x03;
  4823. cbp_b = (h-> top_cbp>>4)&0x03;
  4824. ctx = 0;
  4825. if( cbp_a > 0 ) ctx++;
  4826. if( cbp_b > 0 ) ctx += 2;
  4827. if( get_cabac( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
  4828. return 0;
  4829. ctx = 4;
  4830. if( cbp_a == 2 ) ctx++;
  4831. if( cbp_b == 2 ) ctx += 2;
  4832. return 1 + get_cabac( &h->cabac, &h->cabac_state[77 + ctx] );
  4833. }
  4834. static int decode_cabac_mb_dqp( H264Context *h) {
  4835. MpegEncContext * const s = &h->s;
  4836. int mbn_xy;
  4837. int ctx = 0;
  4838. int val = 0;
  4839. if( s->mb_x > 0 )
  4840. mbn_xy = s->mb_x + s->mb_y*s->mb_stride - 1;
  4841. else
  4842. mbn_xy = s->mb_width - 1 + (s->mb_y-1)*s->mb_stride;
  4843. if( h->last_qscale_diff != 0 && ( IS_INTRA16x16(s->current_picture.mb_type[mbn_xy] ) || (h->cbp_table[mbn_xy]&0x3f) ) )
  4844. ctx++;
  4845. while( get_cabac( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
  4846. if( ctx < 2 )
  4847. ctx = 2;
  4848. else
  4849. ctx = 3;
  4850. val++;
  4851. if(val > 102) //prevent infinite loop
  4852. return INT_MIN;
  4853. }
  4854. if( val&0x01 )
  4855. return (val + 1)/2;
  4856. else
  4857. return -(val + 1)/2;
  4858. }
  4859. static int decode_cabac_p_mb_sub_type( H264Context *h ) {
  4860. if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
  4861. return 0; /* 8x8 */
  4862. if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
  4863. return 1; /* 8x4 */
  4864. if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
  4865. return 2; /* 4x8 */
  4866. return 3; /* 4x4 */
  4867. }
  4868. static int decode_cabac_b_mb_sub_type( H264Context *h ) {
  4869. int type;
  4870. if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
  4871. return 0; /* B_Direct_8x8 */
  4872. if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
  4873. return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
  4874. type = 3;
  4875. if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
  4876. if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
  4877. return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
  4878. type += 4;
  4879. }
  4880. type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
  4881. type += get_cabac( &h->cabac, &h->cabac_state[39] );
  4882. return type;
  4883. }
  4884. static inline int decode_cabac_mb_transform_size( H264Context *h ) {
  4885. return get_cabac( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
  4886. }
  4887. static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
  4888. int refa = h->ref_cache[list][scan8[n] - 1];
  4889. int refb = h->ref_cache[list][scan8[n] - 8];
  4890. int ref = 0;
  4891. int ctx = 0;
  4892. if( h->slice_type == B_TYPE) {
  4893. if( refa > 0 && !h->direct_cache[scan8[n] - 1] )
  4894. ctx++;
  4895. if( refb > 0 && !h->direct_cache[scan8[n] - 8] )
  4896. ctx += 2;
  4897. } else {
  4898. if( refa > 0 )
  4899. ctx++;
  4900. if( refb > 0 )
  4901. ctx += 2;
  4902. }
  4903. while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
  4904. ref++;
  4905. if( ctx < 4 )
  4906. ctx = 4;
  4907. else
  4908. ctx = 5;
  4909. }
  4910. return ref;
  4911. }
  4912. static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
  4913. int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
  4914. abs( h->mvd_cache[list][scan8[n] - 8][l] );
  4915. int ctxbase = (l == 0) ? 40 : 47;
  4916. int ctx, mvd;
  4917. if( amvd < 3 )
  4918. ctx = 0;
  4919. else if( amvd > 32 )
  4920. ctx = 2;
  4921. else
  4922. ctx = 1;
  4923. if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
  4924. return 0;
  4925. mvd= 1;
  4926. ctx= 3;
  4927. while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
  4928. mvd++;
  4929. if( ctx < 6 )
  4930. ctx++;
  4931. }
  4932. if( mvd >= 9 ) {
  4933. int k = 3;
  4934. while( get_cabac_bypass( &h->cabac ) ) {
  4935. mvd += 1 << k;
  4936. k++;
  4937. }
  4938. while( k-- ) {
  4939. if( get_cabac_bypass( &h->cabac ) )
  4940. mvd += 1 << k;
  4941. }
  4942. }
  4943. if( get_cabac_bypass( &h->cabac ) ) return -mvd;
  4944. else return mvd;
  4945. }
  4946. static int inline get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) {
  4947. int nza, nzb;
  4948. int ctx = 0;
  4949. if( cat == 0 ) {
  4950. nza = h->left_cbp&0x100;
  4951. nzb = h-> top_cbp&0x100;
  4952. } else if( cat == 1 || cat == 2 ) {
  4953. nza = h->non_zero_count_cache[scan8[idx] - 1];
  4954. nzb = h->non_zero_count_cache[scan8[idx] - 8];
  4955. } else if( cat == 3 ) {
  4956. nza = (h->left_cbp>>(6+idx))&0x01;
  4957. nzb = (h-> top_cbp>>(6+idx))&0x01;
  4958. } else {
  4959. assert(cat == 4);
  4960. nza = h->non_zero_count_cache[scan8[16+idx] - 1];
  4961. nzb = h->non_zero_count_cache[scan8[16+idx] - 8];
  4962. }
  4963. if( nza > 0 )
  4964. ctx++;
  4965. if( nzb > 0 )
  4966. ctx += 2;
  4967. return ctx + 4 * cat;
  4968. }
  4969. static int decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff) {
  4970. const int mb_xy = h->s.mb_x + h->s.mb_y*h->s.mb_stride;
  4971. static const int significant_coeff_flag_field_offset[2] = { 105, 277 };
  4972. static const int last_significant_coeff_flag_field_offset[2] = { 166, 338 };
  4973. static const int significant_coeff_flag_offset[6] = { 0, 15, 29, 44, 47, 297 };
  4974. static const int last_significant_coeff_flag_offset[6] = { 0, 15, 29, 44, 47, 251 };
  4975. static const int coeff_abs_level_m1_offset[6] = { 227+0, 227+10, 227+20, 227+30, 227+39, 426 };
  4976. static const int significant_coeff_flag_offset_8x8[63] = {
  4977. 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
  4978. 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
  4979. 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
  4980. 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12
  4981. };
  4982. static const int last_coeff_flag_offset_8x8[63] = {
  4983. 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  4984. 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  4985. 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
  4986. 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
  4987. };
  4988. int index[64];
  4989. int i, last;
  4990. int coeff_count = 0;
  4991. int abslevel1 = 1;
  4992. int abslevelgt1 = 0;
  4993. uint8_t *significant_coeff_ctx_base;
  4994. uint8_t *last_coeff_ctx_base;
  4995. uint8_t *abs_level_m1_ctx_base;
  4996. /* cat: 0-> DC 16x16 n = 0
  4997. * 1-> AC 16x16 n = luma4x4idx
  4998. * 2-> Luma4x4 n = luma4x4idx
  4999. * 3-> DC Chroma n = iCbCr
  5000. * 4-> AC Chroma n = 4 * iCbCr + chroma4x4idx
  5001. * 5-> Luma8x8 n = 4 * luma8x8idx
  5002. */
  5003. /* read coded block flag */
  5004. if( cat != 5 ) {
  5005. if( get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n ) ] ) == 0 ) {
  5006. if( cat == 1 || cat == 2 )
  5007. h->non_zero_count_cache[scan8[n]] = 0;
  5008. else if( cat == 4 )
  5009. h->non_zero_count_cache[scan8[16+n]] = 0;
  5010. return 0;
  5011. }
  5012. }
  5013. significant_coeff_ctx_base = h->cabac_state
  5014. + significant_coeff_flag_offset[cat]
  5015. + significant_coeff_flag_field_offset[h->mb_field_decoding_flag];
  5016. last_coeff_ctx_base = h->cabac_state
  5017. + last_significant_coeff_flag_offset[cat]
  5018. + last_significant_coeff_flag_field_offset[h->mb_field_decoding_flag];
  5019. abs_level_m1_ctx_base = h->cabac_state
  5020. + coeff_abs_level_m1_offset[cat];
  5021. if( cat == 5 ) {
  5022. #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
  5023. for(last= 0; last < coefs; last++) { \
  5024. uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
  5025. if( get_cabac( &h->cabac, sig_ctx )) { \
  5026. uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
  5027. index[coeff_count++] = last; \
  5028. if( get_cabac( &h->cabac, last_ctx ) ) { \
  5029. last= max_coeff; \
  5030. break; \
  5031. } \
  5032. } \
  5033. }
  5034. DECODE_SIGNIFICANCE( 63, significant_coeff_flag_offset_8x8[last],
  5035. last_coeff_flag_offset_8x8[last] );
  5036. } else {
  5037. DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
  5038. }
  5039. if( last == max_coeff -1 ) {
  5040. index[coeff_count++] = last;
  5041. }
  5042. assert(coeff_count > 0);
  5043. if( cat == 0 )
  5044. h->cbp_table[mb_xy] |= 0x100;
  5045. else if( cat == 1 || cat == 2 )
  5046. h->non_zero_count_cache[scan8[n]] = coeff_count;
  5047. else if( cat == 3 )
  5048. h->cbp_table[mb_xy] |= 0x40 << n;
  5049. else if( cat == 4 )
  5050. h->non_zero_count_cache[scan8[16+n]] = coeff_count;
  5051. else {
  5052. assert( cat == 5 );
  5053. fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
  5054. }
  5055. for( i = coeff_count - 1; i >= 0; i-- ) {
  5056. uint8_t *ctx = (abslevelgt1 != 0 ? 0 : FFMIN( 4, abslevel1 )) + abs_level_m1_ctx_base;
  5057. int j= scantable[index[i]];
  5058. if( get_cabac( &h->cabac, ctx ) == 0 ) {
  5059. if( !qmul ) {
  5060. if( get_cabac_bypass( &h->cabac ) ) block[j] = -1;
  5061. else block[j] = 1;
  5062. }else{
  5063. if( get_cabac_bypass( &h->cabac ) ) block[j] = (-qmul[j] + 32) >> 6;
  5064. else block[j] = ( qmul[j] + 32) >> 6;
  5065. }
  5066. abslevel1++;
  5067. } else {
  5068. int coeff_abs = 2;
  5069. ctx = 5 + FFMIN( 4, abslevelgt1 ) + abs_level_m1_ctx_base;
  5070. while( coeff_abs < 15 && get_cabac( &h->cabac, ctx ) ) {
  5071. coeff_abs++;
  5072. }
  5073. if( coeff_abs >= 15 ) {
  5074. int j = 0;
  5075. while( get_cabac_bypass( &h->cabac ) ) {
  5076. coeff_abs += 1 << j;
  5077. j++;
  5078. }
  5079. while( j-- ) {
  5080. if( get_cabac_bypass( &h->cabac ) )
  5081. coeff_abs += 1 << j ;
  5082. }
  5083. }
  5084. if( !qmul ) {
  5085. if( get_cabac_bypass( &h->cabac ) ) block[j] = -coeff_abs;
  5086. else block[j] = coeff_abs;
  5087. }else{
  5088. if( get_cabac_bypass( &h->cabac ) ) block[j] = (-coeff_abs * qmul[j] + 32) >> 6;
  5089. else block[j] = ( coeff_abs * qmul[j] + 32) >> 6;
  5090. }
  5091. abslevelgt1++;
  5092. }
  5093. }
  5094. return 0;
  5095. }
  5096. static void inline compute_mb_neighbors(H264Context *h)
  5097. {
  5098. MpegEncContext * const s = &h->s;
  5099. const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
  5100. h->top_mb_xy = mb_xy - s->mb_stride;
  5101. h->left_mb_xy[0] = mb_xy - 1;
  5102. if(h->mb_aff_frame){
  5103. const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride;
  5104. const int top_pair_xy = pair_xy - s->mb_stride;
  5105. const int top_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
  5106. const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
  5107. const int curr_mb_frame_flag = !h->mb_field_decoding_flag;
  5108. const int bottom = (s->mb_y & 1);
  5109. if (bottom
  5110. ? !curr_mb_frame_flag // bottom macroblock
  5111. : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock
  5112. ) {
  5113. h->top_mb_xy -= s->mb_stride;
  5114. }
  5115. if (left_mb_frame_flag != curr_mb_frame_flag) {
  5116. h->left_mb_xy[0] = pair_xy - 1;
  5117. }
  5118. }
  5119. return;
  5120. }
  5121. /**
  5122. * decodes a macroblock
  5123. * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
  5124. */
  5125. static int decode_mb_cabac(H264Context *h) {
  5126. MpegEncContext * const s = &h->s;
  5127. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  5128. int mb_type, partition_count, cbp = 0;
  5129. int dct8x8_allowed= h->pps.transform_8x8_mode;
  5130. s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong?)
  5131. tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
  5132. if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) {
  5133. /* read skip flags */
  5134. if( decode_cabac_mb_skip( h ) ) {
  5135. decode_mb_skip(h);
  5136. h->cbp_table[mb_xy] = 0;
  5137. h->chroma_pred_mode_table[mb_xy] = 0;
  5138. h->last_qscale_diff = 0;
  5139. return 0;
  5140. }
  5141. }
  5142. if(h->mb_aff_frame){
  5143. if ( ((s->mb_y&1) == 0) || h->prev_mb_skipped)
  5144. h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
  5145. }else
  5146. h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME);
  5147. h->prev_mb_skipped = 0;
  5148. compute_mb_neighbors(h);
  5149. if( ( mb_type = decode_cabac_mb_type( h ) ) < 0 ) {
  5150. av_log( h->s.avctx, AV_LOG_ERROR, "decode_cabac_mb_type failed\n" );
  5151. return -1;
  5152. }
  5153. if( h->slice_type == B_TYPE ) {
  5154. if( mb_type < 23 ){
  5155. partition_count= b_mb_type_info[mb_type].partition_count;
  5156. mb_type= b_mb_type_info[mb_type].type;
  5157. }else{
  5158. mb_type -= 23;
  5159. goto decode_intra_mb;
  5160. }
  5161. } else if( h->slice_type == P_TYPE ) {
  5162. if( mb_type < 5) {
  5163. partition_count= p_mb_type_info[mb_type].partition_count;
  5164. mb_type= p_mb_type_info[mb_type].type;
  5165. } else {
  5166. mb_type -= 5;
  5167. goto decode_intra_mb;
  5168. }
  5169. } else {
  5170. assert(h->slice_type == I_TYPE);
  5171. decode_intra_mb:
  5172. partition_count = 0;
  5173. cbp= i_mb_type_info[mb_type].cbp;
  5174. h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
  5175. mb_type= i_mb_type_info[mb_type].type;
  5176. }
  5177. if(h->mb_field_decoding_flag)
  5178. mb_type |= MB_TYPE_INTERLACED;
  5179. h->slice_table[ mb_xy ]= h->slice_num;
  5180. if(IS_INTRA_PCM(mb_type)) {
  5181. const uint8_t *ptr;
  5182. unsigned int x, y;
  5183. // We assume these blocks are very rare so we dont optimize it.
  5184. // FIXME The two following lines get the bitstream position in the cabac
  5185. // decode, I think it should be done by a function in cabac.h (or cabac.c).
  5186. ptr= h->cabac.bytestream;
  5187. if (h->cabac.low&0x1) ptr-=CABAC_BITS/8;
  5188. // The pixels are stored in the same order as levels in h->mb array.
  5189. for(y=0; y<16; y++){
  5190. const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3);
  5191. for(x=0; x<16; x++){
  5192. tprintf("LUMA ICPM LEVEL (%3d)\n", *ptr);
  5193. h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= *ptr++;
  5194. }
  5195. }
  5196. for(y=0; y<8; y++){
  5197. const int index= 256 + 4*(y&3) + 32*(y>>2);
  5198. for(x=0; x<8; x++){
  5199. tprintf("CHROMA U ICPM LEVEL (%3d)\n", *ptr);
  5200. h->mb[index + (x&3) + 16*(x>>2)]= *ptr++;
  5201. }
  5202. }
  5203. for(y=0; y<8; y++){
  5204. const int index= 256 + 64 + 4*(y&3) + 32*(y>>2);
  5205. for(x=0; x<8; x++){
  5206. tprintf("CHROMA V ICPM LEVEL (%3d)\n", *ptr);
  5207. h->mb[index + (x&3) + 16*(x>>2)]= *ptr++;
  5208. }
  5209. }
  5210. ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
  5211. // All blocks are present
  5212. h->cbp_table[mb_xy] = 0x1ef;
  5213. h->chroma_pred_mode_table[mb_xy] = 0;
  5214. // In deblocking, the quantizer is 0
  5215. s->current_picture.qscale_table[mb_xy]= 0;
  5216. h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, 0);
  5217. // All coeffs are present
  5218. memset(h->non_zero_count[mb_xy], 16, 16);
  5219. s->current_picture.mb_type[mb_xy]= mb_type;
  5220. return 0;
  5221. }
  5222. fill_caches(h, mb_type, 0);
  5223. if( IS_INTRA( mb_type ) ) {
  5224. int i;
  5225. if( IS_INTRA4x4( mb_type ) ) {
  5226. if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) {
  5227. mb_type |= MB_TYPE_8x8DCT;
  5228. for( i = 0; i < 16; i+=4 ) {
  5229. int pred = pred_intra_mode( h, i );
  5230. int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
  5231. fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
  5232. }
  5233. } else {
  5234. for( i = 0; i < 16; i++ ) {
  5235. int pred = pred_intra_mode( h, i );
  5236. h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
  5237. //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
  5238. }
  5239. }
  5240. write_back_intra_pred_mode(h);
  5241. if( check_intra4x4_pred_mode(h) < 0 ) return -1;
  5242. } else {
  5243. h->intra16x16_pred_mode= check_intra_pred_mode( h, h->intra16x16_pred_mode );
  5244. if( h->intra16x16_pred_mode < 0 ) return -1;
  5245. }
  5246. h->chroma_pred_mode_table[mb_xy] =
  5247. h->chroma_pred_mode = decode_cabac_mb_chroma_pre_mode( h );
  5248. h->chroma_pred_mode= check_intra_pred_mode( h, h->chroma_pred_mode );
  5249. if( h->chroma_pred_mode < 0 ) return -1;
  5250. } else if( partition_count == 4 ) {
  5251. int i, j, sub_partition_count[4], list, ref[2][4];
  5252. if( h->slice_type == B_TYPE ) {
  5253. for( i = 0; i < 4; i++ ) {
  5254. h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
  5255. sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
  5256. h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
  5257. }
  5258. if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1])
  5259. || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {
  5260. pred_direct_motion(h, &mb_type);
  5261. if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) {
  5262. for( i = 0; i < 4; i++ )
  5263. if( IS_DIRECT(h->sub_mb_type[i]) )
  5264. fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 );
  5265. }
  5266. }
  5267. } else {
  5268. for( i = 0; i < 4; i++ ) {
  5269. h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
  5270. sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
  5271. h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
  5272. }
  5273. }
  5274. for( list = 0; list < 2; list++ ) {
  5275. if( h->ref_count[list] > 0 ) {
  5276. for( i = 0; i < 4; i++ ) {
  5277. if(IS_DIRECT(h->sub_mb_type[i])) continue;
  5278. if(IS_DIR(h->sub_mb_type[i], 0, list)){
  5279. if( h->ref_count[list] > 1 )
  5280. ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
  5281. else
  5282. ref[list][i] = 0;
  5283. } else {
  5284. ref[list][i] = -1;
  5285. }
  5286. h->ref_cache[list][ scan8[4*i]+1 ]=
  5287. h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
  5288. }
  5289. }
  5290. }
  5291. if(dct8x8_allowed)
  5292. dct8x8_allowed = get_dct8x8_allowed(h);
  5293. for(list=0; list<2; list++){
  5294. for(i=0; i<4; i++){
  5295. if(IS_DIRECT(h->sub_mb_type[i])){
  5296. fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
  5297. continue;
  5298. }
  5299. h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ];
  5300. if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
  5301. const int sub_mb_type= h->sub_mb_type[i];
  5302. const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
  5303. for(j=0; j<sub_partition_count[i]; j++){
  5304. int mpx, mpy;
  5305. int mx, my;
  5306. const int index= 4*i + block_width*j;
  5307. int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
  5308. int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
  5309. pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);
  5310. mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );
  5311. my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );
  5312. tprintf("final mv:%d %d\n", mx, my);
  5313. if(IS_SUB_8X8(sub_mb_type)){
  5314. mv_cache[ 0 ][0]= mv_cache[ 1 ][0]=
  5315. mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
  5316. mv_cache[ 0 ][1]= mv_cache[ 1 ][1]=
  5317. mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
  5318. mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]=
  5319. mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
  5320. mvd_cache[ 0 ][1]= mvd_cache[ 1 ][1]=
  5321. mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
  5322. }else if(IS_SUB_8X4(sub_mb_type)){
  5323. mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx;
  5324. mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my;
  5325. mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]= mx- mpx;
  5326. mvd_cache[ 0 ][1]= mvd_cache[ 1 ][1]= my - mpy;
  5327. }else if(IS_SUB_4X8(sub_mb_type)){
  5328. mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx;
  5329. mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my;
  5330. mvd_cache[ 0 ][0]= mvd_cache[ 8 ][0]= mx - mpx;
  5331. mvd_cache[ 0 ][1]= mvd_cache[ 8 ][1]= my - mpy;
  5332. }else{
  5333. assert(IS_SUB_4X4(sub_mb_type));
  5334. mv_cache[ 0 ][0]= mx;
  5335. mv_cache[ 0 ][1]= my;
  5336. mvd_cache[ 0 ][0]= mx - mpx;
  5337. mvd_cache[ 0 ][1]= my - mpy;
  5338. }
  5339. }
  5340. }else{
  5341. uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
  5342. uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];
  5343. p[0] = p[1] = p[8] = p[9] = 0;
  5344. pd[0]= pd[1]= pd[8]= pd[9]= 0;
  5345. }
  5346. }
  5347. }
  5348. } else if( IS_DIRECT(mb_type) ) {
  5349. pred_direct_motion(h, &mb_type);
  5350. fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
  5351. fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
  5352. dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
  5353. } else {
  5354. int list, mx, my, i, mpx, mpy;
  5355. if(IS_16X16(mb_type)){
  5356. for(list=0; list<2; list++){
  5357. if(IS_DIR(mb_type, 0, list)){
  5358. if(h->ref_count[list] > 0 ){
  5359. const int ref = h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 0 ) : 0;
  5360. fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
  5361. }
  5362. }else
  5363. fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1);
  5364. }
  5365. for(list=0; list<2; list++){
  5366. if(IS_DIR(mb_type, 0, list)){
  5367. pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);
  5368. mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
  5369. my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
  5370. tprintf("final mv:%d %d\n", mx, my);
  5371. fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
  5372. fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
  5373. }else
  5374. fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
  5375. }
  5376. }
  5377. else if(IS_16X8(mb_type)){
  5378. for(list=0; list<2; list++){
  5379. if(h->ref_count[list]>0){
  5380. for(i=0; i<2; i++){
  5381. if(IS_DIR(mb_type, i, list)){
  5382. const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 8*i ) : 0;
  5383. fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
  5384. }else
  5385. fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
  5386. }
  5387. }
  5388. }
  5389. for(list=0; list<2; list++){
  5390. for(i=0; i<2; i++){
  5391. if(IS_DIR(mb_type, i, list)){
  5392. pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);
  5393. mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );
  5394. my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );
  5395. tprintf("final mv:%d %d\n", mx, my);
  5396. fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);
  5397. fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
  5398. }else{
  5399. fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
  5400. fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
  5401. }
  5402. }
  5403. }
  5404. }else{
  5405. assert(IS_8X16(mb_type));
  5406. for(list=0; list<2; list++){
  5407. if(h->ref_count[list]>0){
  5408. for(i=0; i<2; i++){
  5409. if(IS_DIR(mb_type, i, list)){ //FIXME optimize
  5410. const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 4*i ) : 0;
  5411. fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
  5412. }else
  5413. fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
  5414. }
  5415. }
  5416. }
  5417. for(list=0; list<2; list++){
  5418. for(i=0; i<2; i++){
  5419. if(IS_DIR(mb_type, i, list)){
  5420. pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);
  5421. mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );
  5422. my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );
  5423. tprintf("final mv:%d %d\n", mx, my);
  5424. fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
  5425. fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
  5426. }else{
  5427. fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
  5428. fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
  5429. }
  5430. }
  5431. }
  5432. }
  5433. }
  5434. if( IS_INTER( mb_type ) ) {
  5435. h->chroma_pred_mode_table[mb_xy] = 0;
  5436. write_back_motion( h, mb_type );
  5437. }
  5438. if( !IS_INTRA16x16( mb_type ) ) {
  5439. cbp = decode_cabac_mb_cbp_luma( h );
  5440. cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
  5441. }
  5442. h->cbp_table[mb_xy] = cbp;
  5443. if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
  5444. if( decode_cabac_mb_transform_size( h ) )
  5445. mb_type |= MB_TYPE_8x8DCT;
  5446. }
  5447. s->current_picture.mb_type[mb_xy]= mb_type;
  5448. if( cbp || IS_INTRA16x16( mb_type ) ) {
  5449. const uint8_t *scan, *scan8x8, *dc_scan;
  5450. int dqp;
  5451. if(IS_INTERLACED(mb_type)){
  5452. scan= s->qscale ? h->field_scan : h->field_scan_q0;
  5453. dc_scan= luma_dc_field_scan;
  5454. }else{
  5455. scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
  5456. dc_scan= luma_dc_zigzag_scan;
  5457. }
  5458. scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
  5459. h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h );
  5460. if( dqp == INT_MIN ){
  5461. av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
  5462. return -1;
  5463. }
  5464. s->qscale += dqp;
  5465. if(((unsigned)s->qscale) > 51){
  5466. if(s->qscale<0) s->qscale+= 52;
  5467. else s->qscale-= 52;
  5468. }
  5469. h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale);
  5470. if( IS_INTRA16x16( mb_type ) ) {
  5471. int i;
  5472. //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
  5473. if( decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16) < 0)
  5474. return -1;
  5475. if( cbp&15 ) {
  5476. for( i = 0; i < 16; i++ ) {
  5477. //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
  5478. if( decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 )
  5479. return -1;
  5480. }
  5481. } else {
  5482. fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
  5483. }
  5484. } else {
  5485. int i8x8, i4x4;
  5486. for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
  5487. if( cbp & (1<<i8x8) ) {
  5488. if( IS_8x8DCT(mb_type) ) {
  5489. if( decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
  5490. scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64) < 0 )
  5491. return -1;
  5492. } else
  5493. for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
  5494. const int index = 4*i8x8 + i4x4;
  5495. //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
  5496. 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 )
  5497. return -1;
  5498. }
  5499. } else {
  5500. uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
  5501. nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
  5502. }
  5503. }
  5504. }
  5505. if( cbp&0x30 ){
  5506. int c;
  5507. for( c = 0; c < 2; c++ ) {
  5508. //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
  5509. if( decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4) < 0)
  5510. return -1;
  5511. }
  5512. }
  5513. if( cbp&0x20 ) {
  5514. int c, i;
  5515. for( c = 0; c < 2; c++ ) {
  5516. for( i = 0; i < 4; i++ ) {
  5517. const int index = 16 + 4 * c + i;
  5518. //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
  5519. 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)
  5520. return -1;
  5521. }
  5522. }
  5523. } else {
  5524. uint8_t * const nnz= &h->non_zero_count_cache[0];
  5525. nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
  5526. nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
  5527. }
  5528. } else {
  5529. uint8_t * const nnz= &h->non_zero_count_cache[0];
  5530. fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
  5531. nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
  5532. nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
  5533. }
  5534. s->current_picture.qscale_table[mb_xy]= s->qscale;
  5535. write_back_non_zero_count(h);
  5536. return 0;
  5537. }
  5538. static void filter_mb_edgev( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) {
  5539. int i, d;
  5540. const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 );
  5541. const int alpha = alpha_table[index_a];
  5542. const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )];
  5543. if( bS[0] < 4 ) {
  5544. int8_t tc[4];
  5545. for(i=0; i<4; i++)
  5546. tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] : -1;
  5547. h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc);
  5548. } else {
  5549. /* 16px edge length, because bS=4 is triggered by being at
  5550. * the edge of an intra MB, so all 4 bS are the same */
  5551. for( d = 0; d < 16; d++ ) {
  5552. const int p0 = pix[-1];
  5553. const int p1 = pix[-2];
  5554. const int p2 = pix[-3];
  5555. const int q0 = pix[0];
  5556. const int q1 = pix[1];
  5557. const int q2 = pix[2];
  5558. if( ABS( p0 - q0 ) < alpha &&
  5559. ABS( p1 - p0 ) < beta &&
  5560. ABS( q1 - q0 ) < beta ) {
  5561. if(ABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
  5562. if( ABS( p2 - p0 ) < beta)
  5563. {
  5564. const int p3 = pix[-4];
  5565. /* p0', p1', p2' */
  5566. pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
  5567. pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
  5568. pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
  5569. } else {
  5570. /* p0' */
  5571. pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
  5572. }
  5573. if( ABS( q2 - q0 ) < beta)
  5574. {
  5575. const int q3 = pix[3];
  5576. /* q0', q1', q2' */
  5577. pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
  5578. pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
  5579. pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
  5580. } else {
  5581. /* q0' */
  5582. pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
  5583. }
  5584. }else{
  5585. /* p0', q0' */
  5586. pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
  5587. pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
  5588. }
  5589. 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]);
  5590. }
  5591. pix += stride;
  5592. }
  5593. }
  5594. }
  5595. static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) {
  5596. int i;
  5597. const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 );
  5598. const int alpha = alpha_table[index_a];
  5599. const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )];
  5600. if( bS[0] < 4 ) {
  5601. int8_t tc[4];
  5602. for(i=0; i<4; i++)
  5603. tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] + 1 : 0;
  5604. h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc);
  5605. } else {
  5606. h->s.dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta);
  5607. }
  5608. }
  5609. static void filter_mb_mbaff_edgev( H264Context *h, uint8_t *pix, int stride, int bS[8], int qp[2] ) {
  5610. int i;
  5611. for( i = 0; i < 16; i++, pix += stride) {
  5612. int index_a;
  5613. int alpha;
  5614. int beta;
  5615. int qp_index;
  5616. int bS_index = (i >> 1);
  5617. if (h->mb_field_decoding_flag) {
  5618. bS_index &= ~1;
  5619. bS_index |= (i & 1);
  5620. }
  5621. if( bS[bS_index] == 0 ) {
  5622. continue;
  5623. }
  5624. qp_index = h->mb_field_decoding_flag ? (i & 1) : (i >> 3);
  5625. index_a = clip( qp[qp_index] + h->slice_alpha_c0_offset, 0, 51 );
  5626. alpha = alpha_table[index_a];
  5627. beta = beta_table[clip( qp[qp_index] + h->slice_beta_offset, 0, 51 )];
  5628. if( bS[bS_index] < 4 ) {
  5629. const int tc0 = tc0_table[index_a][bS[bS_index] - 1];
  5630. /* 4px edge length */
  5631. const int p0 = pix[-1];
  5632. const int p1 = pix[-2];
  5633. const int p2 = pix[-3];
  5634. const int q0 = pix[0];
  5635. const int q1 = pix[1];
  5636. const int q2 = pix[2];
  5637. if( ABS( p0 - q0 ) < alpha &&
  5638. ABS( p1 - p0 ) < beta &&
  5639. ABS( q1 - q0 ) < beta ) {
  5640. int tc = tc0;
  5641. int i_delta;
  5642. if( ABS( p2 - p0 ) < beta ) {
  5643. pix[-2] = p1 + clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 );
  5644. tc++;
  5645. }
  5646. if( ABS( q2 - q0 ) < beta ) {
  5647. pix[1] = q1 + clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 );
  5648. tc++;
  5649. }
  5650. i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
  5651. pix[-1] = clip_uint8( p0 + i_delta ); /* p0' */
  5652. pix[0] = clip_uint8( q0 - i_delta ); /* q0' */
  5653. 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);
  5654. }
  5655. }else{
  5656. /* 4px edge length */
  5657. const int p0 = pix[-1];
  5658. const int p1 = pix[-2];
  5659. const int p2 = pix[-3];
  5660. const int q0 = pix[0];
  5661. const int q1 = pix[1];
  5662. const int q2 = pix[2];
  5663. if( ABS( p0 - q0 ) < alpha &&
  5664. ABS( p1 - p0 ) < beta &&
  5665. ABS( q1 - q0 ) < beta ) {
  5666. if(ABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
  5667. if( ABS( p2 - p0 ) < beta)
  5668. {
  5669. const int p3 = pix[-4];
  5670. /* p0', p1', p2' */
  5671. pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
  5672. pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
  5673. pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
  5674. } else {
  5675. /* p0' */
  5676. pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
  5677. }
  5678. if( ABS( q2 - q0 ) < beta)
  5679. {
  5680. const int q3 = pix[3];
  5681. /* q0', q1', q2' */
  5682. pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
  5683. pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
  5684. pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
  5685. } else {
  5686. /* q0' */
  5687. pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
  5688. }
  5689. }else{
  5690. /* p0', q0' */
  5691. pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
  5692. pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
  5693. }
  5694. 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]);
  5695. }
  5696. }
  5697. }
  5698. }
  5699. static void filter_mb_mbaff_edgecv( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp[2] ) {
  5700. int i;
  5701. for( i = 0; i < 8; i++, pix += stride) {
  5702. int index_a;
  5703. int alpha;
  5704. int beta;
  5705. int qp_index;
  5706. int bS_index = i;
  5707. if( bS[bS_index] == 0 ) {
  5708. continue;
  5709. }
  5710. qp_index = h->mb_field_decoding_flag ? (i & 1) : (i >> 3);
  5711. index_a = clip( qp[qp_index] + h->slice_alpha_c0_offset, 0, 51 );
  5712. alpha = alpha_table[index_a];
  5713. beta = beta_table[clip( qp[qp_index] + h->slice_beta_offset, 0, 51 )];
  5714. if( bS[bS_index] < 4 ) {
  5715. const int tc = tc0_table[index_a][bS[bS_index] - 1] + 1;
  5716. /* 2px edge length (because we use same bS than the one for luma) */
  5717. const int p0 = pix[-1];
  5718. const int p1 = pix[-2];
  5719. const int q0 = pix[0];
  5720. const int q1 = pix[1];
  5721. if( ABS( p0 - q0 ) < alpha &&
  5722. ABS( p1 - p0 ) < beta &&
  5723. ABS( q1 - q0 ) < beta ) {
  5724. const int i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
  5725. pix[-1] = clip_uint8( p0 + i_delta ); /* p0' */
  5726. pix[0] = clip_uint8( q0 - i_delta ); /* q0' */
  5727. 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);
  5728. }
  5729. }else{
  5730. const int p0 = pix[-1];
  5731. const int p1 = pix[-2];
  5732. const int q0 = pix[0];
  5733. const int q1 = pix[1];
  5734. if( ABS( p0 - q0 ) < alpha &&
  5735. ABS( p1 - p0 ) < beta &&
  5736. ABS( q1 - q0 ) < beta ) {
  5737. pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; /* p0' */
  5738. pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; /* q0' */
  5739. 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]);
  5740. }
  5741. }
  5742. }
  5743. }
  5744. static void filter_mb_edgeh( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) {
  5745. int i, d;
  5746. const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 );
  5747. const int alpha = alpha_table[index_a];
  5748. const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )];
  5749. const int pix_next = stride;
  5750. if( bS[0] < 4 ) {
  5751. int8_t tc[4];
  5752. for(i=0; i<4; i++)
  5753. tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] : -1;
  5754. h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc);
  5755. } else {
  5756. /* 16px edge length, see filter_mb_edgev */
  5757. for( d = 0; d < 16; d++ ) {
  5758. const int p0 = pix[-1*pix_next];
  5759. const int p1 = pix[-2*pix_next];
  5760. const int p2 = pix[-3*pix_next];
  5761. const int q0 = pix[0];
  5762. const int q1 = pix[1*pix_next];
  5763. const int q2 = pix[2*pix_next];
  5764. if( ABS( p0 - q0 ) < alpha &&
  5765. ABS( p1 - p0 ) < beta &&
  5766. ABS( q1 - q0 ) < beta ) {
  5767. const int p3 = pix[-4*pix_next];
  5768. const int q3 = pix[ 3*pix_next];
  5769. if(ABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
  5770. if( ABS( p2 - p0 ) < beta) {
  5771. /* p0', p1', p2' */
  5772. pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
  5773. pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
  5774. pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
  5775. } else {
  5776. /* p0' */
  5777. pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
  5778. }
  5779. if( ABS( q2 - q0 ) < beta) {
  5780. /* q0', q1', q2' */
  5781. pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
  5782. pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
  5783. pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
  5784. } else {
  5785. /* q0' */
  5786. pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
  5787. }
  5788. }else{
  5789. /* p0', q0' */
  5790. pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
  5791. pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
  5792. }
  5793. 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]);
  5794. }
  5795. pix++;
  5796. }
  5797. }
  5798. }
  5799. static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) {
  5800. int i;
  5801. const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 );
  5802. const int alpha = alpha_table[index_a];
  5803. const int beta = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )];
  5804. if( bS[0] < 4 ) {
  5805. int8_t tc[4];
  5806. for(i=0; i<4; i++)
  5807. tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] + 1 : 0;
  5808. h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc);
  5809. } else {
  5810. h->s.dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta);
  5811. }
  5812. }
  5813. 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) {
  5814. MpegEncContext * const s = &h->s;
  5815. const int mb_xy= mb_x + mb_y*s->mb_stride;
  5816. int first_vertical_edge_done = 0;
  5817. int dir;
  5818. /* FIXME: A given frame may occupy more than one position in
  5819. * the reference list. So ref2frm should be populated with
  5820. * frame numbers, not indices. */
  5821. static const int ref2frm[18] = {-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
  5822. //for sufficiently low qp, filtering wouldn't do anything
  5823. //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp
  5824. if(!h->mb_aff_frame){
  5825. int qp_thresh = 15 - h->slice_alpha_c0_offset - FFMAX(0, h->pps.chroma_qp_index_offset);
  5826. int qp = s->current_picture.qscale_table[mb_xy];
  5827. if(qp <= qp_thresh
  5828. && (mb_x == 0 || ((qp + s->current_picture.qscale_table[mb_xy-1] + 1)>>1) <= qp_thresh)
  5829. && (mb_y == 0 || ((qp + s->current_picture.qscale_table[h->top_mb_xy] + 1)>>1) <= qp_thresh)){
  5830. return;
  5831. }
  5832. }
  5833. if (h->mb_aff_frame
  5834. // left mb is in picture
  5835. && h->slice_table[mb_xy-1] != 255
  5836. // and current and left pair do not have the same interlaced type
  5837. && (IS_INTERLACED(s->current_picture.mb_type[mb_xy]) != IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]))
  5838. // and left mb is in the same slice if deblocking_filter == 2
  5839. && (h->deblocking_filter!=2 || h->slice_table[mb_xy-1] == h->slice_table[mb_xy])) {
  5840. /* First vertical edge is different in MBAFF frames
  5841. * There are 8 different bS to compute and 2 different Qp
  5842. */
  5843. int bS[8];
  5844. int qp[2];
  5845. int chroma_qp[2];
  5846. int i;
  5847. first_vertical_edge_done = 1;
  5848. for( i = 0; i < 8; i++ ) {
  5849. int y = i>>1;
  5850. int b_idx= 8 + 4 + 8*y;
  5851. int bn_idx= b_idx - 1;
  5852. int mbn_xy = h->mb_field_decoding_flag ? h->left_mb_xy[i>>2] : h->left_mb_xy[i&1];
  5853. if( IS_INTRA( s->current_picture.mb_type[mb_xy] ) ||
  5854. IS_INTRA( s->current_picture.mb_type[mbn_xy] ) ) {
  5855. bS[i] = 4;
  5856. } else if( h->non_zero_count_cache[b_idx] != 0 ||
  5857. /* FIXME: with 8x8dct + cavlc, should check cbp instead of nnz */
  5858. h->non_zero_count_cache[bn_idx] != 0 ) {
  5859. bS[i] = 2;
  5860. } else {
  5861. int l;
  5862. bS[i] = 0;
  5863. for( l = 0; l < 1 + (h->slice_type == B_TYPE); l++ ) {
  5864. if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] ||
  5865. ABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
  5866. ABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= 4 ) {
  5867. bS[i] = 1;
  5868. break;
  5869. }
  5870. }
  5871. }
  5872. }
  5873. if(bS[0]+bS[1]+bS[2]+bS[3] != 0) {
  5874. // Do not use s->qscale as luma quantizer because it has not the same
  5875. // value in IPCM macroblocks.
  5876. qp[0] = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[h->left_mb_xy[0]] + 1 ) >> 1;
  5877. chroma_qp[0] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mb_xy] ) +
  5878. get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[h->left_mb_xy[0]] ) + 1 ) >> 1;
  5879. qp[1] = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[h->left_mb_xy[1]] + 1 ) >> 1;
  5880. chroma_qp[1] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mb_xy] ) +
  5881. get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[h->left_mb_xy[1]] ) + 1 ) >> 1;
  5882. /* Filter edge */
  5883. 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);
  5884. { int i; for (i = 0; i < 8; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }
  5885. filter_mb_mbaff_edgev ( h, &img_y [0], linesize, bS, qp );
  5886. filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, chroma_qp );
  5887. filter_mb_mbaff_edgecv( h, &img_cr[0], uvlinesize, bS, chroma_qp );
  5888. }
  5889. }
  5890. /* dir : 0 -> vertical edge, 1 -> horizontal edge */
  5891. for( dir = 0; dir < 2; dir++ )
  5892. {
  5893. int edge;
  5894. const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy;
  5895. const int mb_type = s->current_picture.mb_type[mb_xy];
  5896. const int mbm_type = s->current_picture.mb_type[mbm_xy];
  5897. int start = h->slice_table[mbm_xy] == 255 ? 1 : 0;
  5898. const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP))
  5899. == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4;
  5900. // how often to recheck mv-based bS when iterating between edges
  5901. const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 :
  5902. (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0;
  5903. // how often to recheck mv-based bS when iterating along each edge
  5904. const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir));
  5905. if (first_vertical_edge_done) {
  5906. start = 1;
  5907. first_vertical_edge_done = 0;
  5908. }
  5909. if (h->deblocking_filter==2 && h->slice_table[mbm_xy] != h->slice_table[mb_xy])
  5910. start = 1;
  5911. /* Calculate bS */
  5912. for( edge = start; edge < edges; edge++ ) {
  5913. /* mbn_xy: neighbor macroblock */
  5914. const int mbn_xy = edge > 0 ? mb_xy : mbm_xy;
  5915. const int mbn_type = s->current_picture.mb_type[mbn_xy];
  5916. int bS[4];
  5917. int qp;
  5918. if( (edge&1) && IS_8x8DCT(mb_type) )
  5919. continue;
  5920. if (h->mb_aff_frame && (dir == 1) && (edge == 0) && ((mb_y & 1) == 0)
  5921. && !IS_INTERLACED(mb_type)
  5922. && IS_INTERLACED(mbn_type)
  5923. ) {
  5924. // This is a special case in the norm where the filtering must
  5925. // be done twice (one each of the field) even if we are in a
  5926. // frame macroblock.
  5927. //
  5928. unsigned int tmp_linesize = 2 * linesize;
  5929. unsigned int tmp_uvlinesize = 2 * uvlinesize;
  5930. int mbn_xy = mb_xy - 2 * s->mb_stride;
  5931. int qp, chroma_qp;
  5932. // first filtering
  5933. if( IS_INTRA(mb_type) ||
  5934. IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) {
  5935. bS[0] = bS[1] = bS[2] = bS[3] = 3;
  5936. } else {
  5937. // TODO
  5938. av_log(h->s.avctx, AV_LOG_ERROR, "both non intra (TODO)\n");
  5939. }
  5940. /* Filter edge */
  5941. // Do not use s->qscale as luma quantizer because it has not the same
  5942. // value in IPCM macroblocks.
  5943. qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
  5944. 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);
  5945. { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }
  5946. filter_mb_edgeh( h, &img_y[0], tmp_linesize, bS, qp );
  5947. chroma_qp = ( h->chroma_qp +
  5948. get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
  5949. filter_mb_edgech( h, &img_cb[0], tmp_uvlinesize, bS, chroma_qp );
  5950. filter_mb_edgech( h, &img_cr[0], tmp_uvlinesize, bS, chroma_qp );
  5951. // second filtering
  5952. mbn_xy += s->mb_stride;
  5953. if( IS_INTRA(mb_type) ||
  5954. IS_INTRA(mbn_type) ) {
  5955. bS[0] = bS[1] = bS[2] = bS[3] = 3;
  5956. } else {
  5957. // TODO
  5958. av_log(h->s.avctx, AV_LOG_ERROR, "both non intra (TODO)\n");
  5959. }
  5960. /* Filter edge */
  5961. // Do not use s->qscale as luma quantizer because it has not the same
  5962. // value in IPCM macroblocks.
  5963. qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
  5964. 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);
  5965. { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }
  5966. filter_mb_edgeh( h, &img_y[linesize], tmp_linesize, bS, qp );
  5967. chroma_qp = ( h->chroma_qp +
  5968. get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
  5969. filter_mb_edgech( h, &img_cb[uvlinesize], tmp_uvlinesize, bS, chroma_qp );
  5970. filter_mb_edgech( h, &img_cr[uvlinesize], tmp_uvlinesize, bS, chroma_qp );
  5971. continue;
  5972. }
  5973. if( IS_INTRA(mb_type) ||
  5974. IS_INTRA(mbn_type) ) {
  5975. int value;
  5976. if (edge == 0) {
  5977. if ( (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type))
  5978. || ((h->mb_aff_frame || (s->picture_structure != PICT_FRAME)) && (dir == 0))
  5979. ) {
  5980. value = 4;
  5981. } else {
  5982. value = 3;
  5983. }
  5984. } else {
  5985. value = 3;
  5986. }
  5987. bS[0] = bS[1] = bS[2] = bS[3] = value;
  5988. } else {
  5989. int i, l;
  5990. int mv_done;
  5991. if( edge & mask_edge ) {
  5992. bS[0] = bS[1] = bS[2] = bS[3] = 0;
  5993. mv_done = 1;
  5994. }
  5995. else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) {
  5996. int b_idx= 8 + 4 + edge * (dir ? 8:1);
  5997. int bn_idx= b_idx - (dir ? 8:1);
  5998. int v = 0;
  5999. for( l = 0; !v && l < 1 + (h->slice_type == B_TYPE); l++ ) {
  6000. v |= ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] ||
  6001. ABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
  6002. ABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= 4;
  6003. }
  6004. bS[0] = bS[1] = bS[2] = bS[3] = v;
  6005. mv_done = 1;
  6006. }
  6007. else
  6008. mv_done = 0;
  6009. for( i = 0; i < 4; i++ ) {
  6010. int x = dir == 0 ? edge : i;
  6011. int y = dir == 0 ? i : edge;
  6012. int b_idx= 8 + 4 + x + 8*y;
  6013. int bn_idx= b_idx - (dir ? 8:1);
  6014. if( h->non_zero_count_cache[b_idx] != 0 ||
  6015. h->non_zero_count_cache[bn_idx] != 0 ) {
  6016. bS[i] = 2;
  6017. }
  6018. else if(!mv_done)
  6019. {
  6020. bS[i] = 0;
  6021. for( l = 0; l < 1 + (h->slice_type == B_TYPE); l++ ) {
  6022. if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] ||
  6023. ABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
  6024. ABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= 4 ) {
  6025. bS[i] = 1;
  6026. break;
  6027. }
  6028. }
  6029. }
  6030. }
  6031. if(bS[0]+bS[1]+bS[2]+bS[3] == 0)
  6032. continue;
  6033. }
  6034. /* Filter edge */
  6035. // Do not use s->qscale as luma quantizer because it has not the same
  6036. // value in IPCM macroblocks.
  6037. qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
  6038. //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]);
  6039. tprintf("filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
  6040. { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }
  6041. if( dir == 0 ) {
  6042. filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp );
  6043. if( (edge&1) == 0 ) {
  6044. int chroma_qp = ( h->chroma_qp +
  6045. get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
  6046. filter_mb_edgecv( h, &img_cb[2*edge], uvlinesize, bS, chroma_qp );
  6047. filter_mb_edgecv( h, &img_cr[2*edge], uvlinesize, bS, chroma_qp );
  6048. }
  6049. } else {
  6050. filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp );
  6051. if( (edge&1) == 0 ) {
  6052. int chroma_qp = ( h->chroma_qp +
  6053. get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
  6054. filter_mb_edgech( h, &img_cb[2*edge*uvlinesize], uvlinesize, bS, chroma_qp );
  6055. filter_mb_edgech( h, &img_cr[2*edge*uvlinesize], uvlinesize, bS, chroma_qp );
  6056. }
  6057. }
  6058. }
  6059. }
  6060. }
  6061. static int decode_slice(H264Context *h){
  6062. MpegEncContext * const s = &h->s;
  6063. const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;
  6064. s->mb_skip_run= -1;
  6065. if( h->pps.cabac ) {
  6066. int i;
  6067. /* realign */
  6068. align_get_bits( &s->gb );
  6069. /* init cabac */
  6070. ff_init_cabac_states( &h->cabac, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64 );
  6071. ff_init_cabac_decoder( &h->cabac,
  6072. s->gb.buffer + get_bits_count(&s->gb)/8,
  6073. ( s->gb.size_in_bits - get_bits_count(&s->gb) + 7)/8);
  6074. /* calculate pre-state */
  6075. for( i= 0; i < 460; i++ ) {
  6076. int pre;
  6077. if( h->slice_type == I_TYPE )
  6078. pre = clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 );
  6079. else
  6080. 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 );
  6081. if( pre <= 63 )
  6082. h->cabac_state[i] = 2 * ( 63 - pre ) + 0;
  6083. else
  6084. h->cabac_state[i] = 2 * ( pre - 64 ) + 1;
  6085. }
  6086. for(;;){
  6087. int ret = decode_mb_cabac(h);
  6088. int eos;
  6089. if(ret>=0) hl_decode_mb(h);
  6090. /* XXX: useless as decode_mb_cabac it doesn't support that ... */
  6091. if( ret >= 0 && h->mb_aff_frame ) { //FIXME optimal? or let mb_decode decode 16x32 ?
  6092. s->mb_y++;
  6093. if(ret>=0) ret = decode_mb_cabac(h);
  6094. if(ret>=0) hl_decode_mb(h);
  6095. s->mb_y--;
  6096. }
  6097. eos = get_cabac_terminate( &h->cabac );
  6098. if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 1) {
  6099. av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
  6100. 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);
  6101. return -1;
  6102. }
  6103. if( ++s->mb_x >= s->mb_width ) {
  6104. s->mb_x = 0;
  6105. ff_draw_horiz_band(s, 16*s->mb_y, 16);
  6106. ++s->mb_y;
  6107. if(h->mb_aff_frame) {
  6108. ++s->mb_y;
  6109. }
  6110. }
  6111. if( eos || s->mb_y >= s->mb_height ) {
  6112. tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
  6113. 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);
  6114. return 0;
  6115. }
  6116. }
  6117. } else {
  6118. for(;;){
  6119. int ret = decode_mb_cavlc(h);
  6120. if(ret>=0) hl_decode_mb(h);
  6121. if(ret>=0 && h->mb_aff_frame){ //FIXME optimal? or let mb_decode decode 16x32 ?
  6122. s->mb_y++;
  6123. ret = decode_mb_cavlc(h);
  6124. if(ret>=0) hl_decode_mb(h);
  6125. s->mb_y--;
  6126. }
  6127. if(ret<0){
  6128. av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
  6129. 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);
  6130. return -1;
  6131. }
  6132. if(++s->mb_x >= s->mb_width){
  6133. s->mb_x=0;
  6134. ff_draw_horiz_band(s, 16*s->mb_y, 16);
  6135. ++s->mb_y;
  6136. if(h->mb_aff_frame) {
  6137. ++s->mb_y;
  6138. }
  6139. if(s->mb_y >= s->mb_height){
  6140. tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
  6141. if(get_bits_count(&s->gb) == s->gb.size_in_bits ) {
  6142. 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);
  6143. return 0;
  6144. }else{
  6145. 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);
  6146. return -1;
  6147. }
  6148. }
  6149. }
  6150. if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){
  6151. tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
  6152. if(get_bits_count(&s->gb) == s->gb.size_in_bits ){
  6153. 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);
  6154. return 0;
  6155. }else{
  6156. 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);
  6157. return -1;
  6158. }
  6159. }
  6160. }
  6161. }
  6162. #if 0
  6163. for(;s->mb_y < s->mb_height; s->mb_y++){
  6164. for(;s->mb_x < s->mb_width; s->mb_x++){
  6165. int ret= decode_mb(h);
  6166. hl_decode_mb(h);
  6167. if(ret<0){
  6168. av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
  6169. 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);
  6170. return -1;
  6171. }
  6172. if(++s->mb_x >= s->mb_width){
  6173. s->mb_x=0;
  6174. if(++s->mb_y >= s->mb_height){
  6175. if(get_bits_count(s->gb) == s->gb.size_in_bits){
  6176. 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);
  6177. return 0;
  6178. }else{
  6179. 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);
  6180. return -1;
  6181. }
  6182. }
  6183. }
  6184. if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){
  6185. if(get_bits_count(s->gb) == s->gb.size_in_bits){
  6186. 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);
  6187. return 0;
  6188. }else{
  6189. 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);
  6190. return -1;
  6191. }
  6192. }
  6193. }
  6194. s->mb_x=0;
  6195. ff_draw_horiz_band(s, 16*s->mb_y, 16);
  6196. }
  6197. #endif
  6198. return -1; //not reached
  6199. }
  6200. static int decode_unregistered_user_data(H264Context *h, int size){
  6201. MpegEncContext * const s = &h->s;
  6202. uint8_t user_data[16+256];
  6203. int e, build, i;
  6204. if(size<16)
  6205. return -1;
  6206. for(i=0; i<sizeof(user_data)-1 && i<size; i++){
  6207. user_data[i]= get_bits(&s->gb, 8);
  6208. }
  6209. user_data[i]= 0;
  6210. e= sscanf(user_data+16, "x264 - core %d"/*%s - H.264/MPEG-4 AVC codec - Copyleft 2005 - http://www.videolan.org/x264.html*/, &build);
  6211. if(e==1 && build>=0)
  6212. h->x264_build= build;
  6213. if(s->avctx->debug & FF_DEBUG_BUGS)
  6214. av_log(s->avctx, AV_LOG_DEBUG, "user data:\"%s\"\n", user_data+16);
  6215. for(; i<size; i++)
  6216. skip_bits(&s->gb, 8);
  6217. return 0;
  6218. }
  6219. static int decode_sei(H264Context *h){
  6220. MpegEncContext * const s = &h->s;
  6221. while(get_bits_count(&s->gb) + 16 < s->gb.size_in_bits){
  6222. int size, type;
  6223. type=0;
  6224. do{
  6225. type+= show_bits(&s->gb, 8);
  6226. }while(get_bits(&s->gb, 8) == 255);
  6227. size=0;
  6228. do{
  6229. size+= show_bits(&s->gb, 8);
  6230. }while(get_bits(&s->gb, 8) == 255);
  6231. switch(type){
  6232. case 5:
  6233. if(decode_unregistered_user_data(h, size) < 0);
  6234. return -1;
  6235. break;
  6236. default:
  6237. skip_bits(&s->gb, 8*size);
  6238. }
  6239. //FIXME check bits here
  6240. align_get_bits(&s->gb);
  6241. }
  6242. return 0;
  6243. }
  6244. static inline void decode_hrd_parameters(H264Context *h, SPS *sps){
  6245. MpegEncContext * const s = &h->s;
  6246. int cpb_count, i;
  6247. cpb_count = get_ue_golomb(&s->gb) + 1;
  6248. get_bits(&s->gb, 4); /* bit_rate_scale */
  6249. get_bits(&s->gb, 4); /* cpb_size_scale */
  6250. for(i=0; i<cpb_count; i++){
  6251. get_ue_golomb(&s->gb); /* bit_rate_value_minus1 */
  6252. get_ue_golomb(&s->gb); /* cpb_size_value_minus1 */
  6253. get_bits1(&s->gb); /* cbr_flag */
  6254. }
  6255. get_bits(&s->gb, 5); /* initial_cpb_removal_delay_length_minus1 */
  6256. get_bits(&s->gb, 5); /* cpb_removal_delay_length_minus1 */
  6257. get_bits(&s->gb, 5); /* dpb_output_delay_length_minus1 */
  6258. get_bits(&s->gb, 5); /* time_offset_length */
  6259. }
  6260. static inline int decode_vui_parameters(H264Context *h, SPS *sps){
  6261. MpegEncContext * const s = &h->s;
  6262. int aspect_ratio_info_present_flag, aspect_ratio_idc;
  6263. int nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag;
  6264. aspect_ratio_info_present_flag= get_bits1(&s->gb);
  6265. if( aspect_ratio_info_present_flag ) {
  6266. aspect_ratio_idc= get_bits(&s->gb, 8);
  6267. if( aspect_ratio_idc == EXTENDED_SAR ) {
  6268. sps->sar.num= get_bits(&s->gb, 16);
  6269. sps->sar.den= get_bits(&s->gb, 16);
  6270. }else if(aspect_ratio_idc < 14){
  6271. sps->sar= pixel_aspect[aspect_ratio_idc];
  6272. }else{
  6273. av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
  6274. return -1;
  6275. }
  6276. }else{
  6277. sps->sar.num=
  6278. sps->sar.den= 0;
  6279. }
  6280. // s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
  6281. if(get_bits1(&s->gb)){ /* overscan_info_present_flag */
  6282. get_bits1(&s->gb); /* overscan_appropriate_flag */
  6283. }
  6284. if(get_bits1(&s->gb)){ /* video_signal_type_present_flag */
  6285. get_bits(&s->gb, 3); /* video_format */
  6286. get_bits1(&s->gb); /* video_full_range_flag */
  6287. if(get_bits1(&s->gb)){ /* colour_description_present_flag */
  6288. get_bits(&s->gb, 8); /* colour_primaries */
  6289. get_bits(&s->gb, 8); /* transfer_characteristics */
  6290. get_bits(&s->gb, 8); /* matrix_coefficients */
  6291. }
  6292. }
  6293. if(get_bits1(&s->gb)){ /* chroma_location_info_present_flag */
  6294. get_ue_golomb(&s->gb); /* chroma_sample_location_type_top_field */
  6295. get_ue_golomb(&s->gb); /* chroma_sample_location_type_bottom_field */
  6296. }
  6297. sps->timing_info_present_flag = get_bits1(&s->gb);
  6298. if(sps->timing_info_present_flag){
  6299. sps->num_units_in_tick = get_bits_long(&s->gb, 32);
  6300. sps->time_scale = get_bits_long(&s->gb, 32);
  6301. sps->fixed_frame_rate_flag = get_bits1(&s->gb);
  6302. }
  6303. nal_hrd_parameters_present_flag = get_bits1(&s->gb);
  6304. if(nal_hrd_parameters_present_flag)
  6305. decode_hrd_parameters(h, sps);
  6306. vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
  6307. if(vcl_hrd_parameters_present_flag)
  6308. decode_hrd_parameters(h, sps);
  6309. if(nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag)
  6310. get_bits1(&s->gb); /* low_delay_hrd_flag */
  6311. get_bits1(&s->gb); /* pic_struct_present_flag */
  6312. sps->bitstream_restriction_flag = get_bits1(&s->gb);
  6313. if(sps->bitstream_restriction_flag){
  6314. get_bits1(&s->gb); /* motion_vectors_over_pic_boundaries_flag */
  6315. get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
  6316. get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
  6317. get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
  6318. get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
  6319. sps->num_reorder_frames = get_ue_golomb(&s->gb);
  6320. get_ue_golomb(&s->gb); /* max_dec_frame_buffering */
  6321. }
  6322. return 0;
  6323. }
  6324. static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
  6325. const uint8_t *jvt_list, const uint8_t *fallback_list){
  6326. MpegEncContext * const s = &h->s;
  6327. int i, last = 8, next = 8;
  6328. const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8;
  6329. if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
  6330. memcpy(factors, fallback_list, size*sizeof(uint8_t));
  6331. else
  6332. for(i=0;i<size;i++){
  6333. if(next)
  6334. next = (last + get_se_golomb(&s->gb)) & 0xff;
  6335. if(!i && !next){ /* matrix not written, we use the preset one */
  6336. memcpy(factors, jvt_list, size*sizeof(uint8_t));
  6337. break;
  6338. }
  6339. last = factors[scan[i]] = next ? next : last;
  6340. }
  6341. }
  6342. static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
  6343. uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
  6344. MpegEncContext * const s = &h->s;
  6345. int fallback_sps = !is_sps && sps->scaling_matrix_present;
  6346. const uint8_t *fallback[4] = {
  6347. fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
  6348. fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
  6349. fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
  6350. fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1]
  6351. };
  6352. if(get_bits1(&s->gb)){
  6353. sps->scaling_matrix_present |= is_sps;
  6354. decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
  6355. decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
  6356. decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
  6357. decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
  6358. decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
  6359. decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
  6360. if(is_sps || pps->transform_8x8_mode){
  6361. decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y
  6362. decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]); // Inter, Y
  6363. }
  6364. } else if(fallback_sps) {
  6365. memcpy(scaling_matrix4, sps->scaling_matrix4, 6*16*sizeof(uint8_t));
  6366. memcpy(scaling_matrix8, sps->scaling_matrix8, 2*64*sizeof(uint8_t));
  6367. }
  6368. }
  6369. static inline int decode_seq_parameter_set(H264Context *h){
  6370. MpegEncContext * const s = &h->s;
  6371. int profile_idc, level_idc;
  6372. int sps_id, i;
  6373. SPS *sps;
  6374. profile_idc= get_bits(&s->gb, 8);
  6375. get_bits1(&s->gb); //constraint_set0_flag
  6376. get_bits1(&s->gb); //constraint_set1_flag
  6377. get_bits1(&s->gb); //constraint_set2_flag
  6378. get_bits1(&s->gb); //constraint_set3_flag
  6379. get_bits(&s->gb, 4); // reserved
  6380. level_idc= get_bits(&s->gb, 8);
  6381. sps_id= get_ue_golomb(&s->gb);
  6382. sps= &h->sps_buffer[ sps_id ];
  6383. sps->profile_idc= profile_idc;
  6384. sps->level_idc= level_idc;
  6385. if(sps->profile_idc >= 100){ //high profile
  6386. if(get_ue_golomb(&s->gb) == 3) //chroma_format_idc
  6387. get_bits1(&s->gb); //residual_color_transform_flag
  6388. get_ue_golomb(&s->gb); //bit_depth_luma_minus8
  6389. get_ue_golomb(&s->gb); //bit_depth_chroma_minus8
  6390. sps->transform_bypass = get_bits1(&s->gb);
  6391. decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
  6392. }else
  6393. sps->scaling_matrix_present = 0;
  6394. sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
  6395. sps->poc_type= get_ue_golomb(&s->gb);
  6396. if(sps->poc_type == 0){ //FIXME #define
  6397. sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
  6398. } else if(sps->poc_type == 1){//FIXME #define
  6399. sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
  6400. sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
  6401. sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
  6402. sps->poc_cycle_length= get_ue_golomb(&s->gb);
  6403. for(i=0; i<sps->poc_cycle_length; i++)
  6404. sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
  6405. }
  6406. if(sps->poc_type > 2){
  6407. av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
  6408. return -1;
  6409. }
  6410. sps->ref_frame_count= get_ue_golomb(&s->gb);
  6411. if(sps->ref_frame_count > MAX_PICTURE_COUNT-2){
  6412. av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
  6413. }
  6414. sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
  6415. sps->mb_width= get_ue_golomb(&s->gb) + 1;
  6416. sps->mb_height= get_ue_golomb(&s->gb) + 1;
  6417. if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
  6418. avcodec_check_dimensions(NULL, 16*sps->mb_width, 16*sps->mb_height))
  6419. return -1;
  6420. sps->frame_mbs_only_flag= get_bits1(&s->gb);
  6421. if(!sps->frame_mbs_only_flag)
  6422. sps->mb_aff= get_bits1(&s->gb);
  6423. else
  6424. sps->mb_aff= 0;
  6425. sps->direct_8x8_inference_flag= get_bits1(&s->gb);
  6426. sps->crop= get_bits1(&s->gb);
  6427. if(sps->crop){
  6428. sps->crop_left = get_ue_golomb(&s->gb);
  6429. sps->crop_right = get_ue_golomb(&s->gb);
  6430. sps->crop_top = get_ue_golomb(&s->gb);
  6431. sps->crop_bottom= get_ue_golomb(&s->gb);
  6432. if(sps->crop_left || sps->crop_top){
  6433. av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
  6434. }
  6435. }else{
  6436. sps->crop_left =
  6437. sps->crop_right =
  6438. sps->crop_top =
  6439. sps->crop_bottom= 0;
  6440. }
  6441. sps->vui_parameters_present_flag= get_bits1(&s->gb);
  6442. if( sps->vui_parameters_present_flag )
  6443. decode_vui_parameters(h, sps);
  6444. if(s->avctx->debug&FF_DEBUG_PICT_INFO){
  6445. 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",
  6446. sps_id, sps->profile_idc, sps->level_idc,
  6447. sps->poc_type,
  6448. sps->ref_frame_count,
  6449. sps->mb_width, sps->mb_height,
  6450. sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
  6451. sps->direct_8x8_inference_flag ? "8B8" : "",
  6452. sps->crop_left, sps->crop_right,
  6453. sps->crop_top, sps->crop_bottom,
  6454. sps->vui_parameters_present_flag ? "VUI" : ""
  6455. );
  6456. }
  6457. return 0;
  6458. }
  6459. static inline int decode_picture_parameter_set(H264Context *h, int bit_length){
  6460. MpegEncContext * const s = &h->s;
  6461. int pps_id= get_ue_golomb(&s->gb);
  6462. PPS *pps= &h->pps_buffer[pps_id];
  6463. pps->sps_id= get_ue_golomb(&s->gb);
  6464. pps->cabac= get_bits1(&s->gb);
  6465. pps->pic_order_present= get_bits1(&s->gb);
  6466. pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
  6467. if(pps->slice_group_count > 1 ){
  6468. pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
  6469. av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
  6470. switch(pps->mb_slice_group_map_type){
  6471. case 0:
  6472. #if 0
  6473. | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
  6474. | run_length[ i ] |1 |ue(v) |
  6475. #endif
  6476. break;
  6477. case 2:
  6478. #if 0
  6479. | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
  6480. |{ | | |
  6481. | top_left_mb[ i ] |1 |ue(v) |
  6482. | bottom_right_mb[ i ] |1 |ue(v) |
  6483. | } | | |
  6484. #endif
  6485. break;
  6486. case 3:
  6487. case 4:
  6488. case 5:
  6489. #if 0
  6490. | slice_group_change_direction_flag |1 |u(1) |
  6491. | slice_group_change_rate_minus1 |1 |ue(v) |
  6492. #endif
  6493. break;
  6494. case 6:
  6495. #if 0
  6496. | slice_group_id_cnt_minus1 |1 |ue(v) |
  6497. | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
  6498. |) | | |
  6499. | slice_group_id[ i ] |1 |u(v) |
  6500. #endif
  6501. break;
  6502. }
  6503. }
  6504. pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
  6505. pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
  6506. if(pps->ref_count[0] > 32 || pps->ref_count[1] > 32){
  6507. av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
  6508. return -1;
  6509. }
  6510. pps->weighted_pred= get_bits1(&s->gb);
  6511. pps->weighted_bipred_idc= get_bits(&s->gb, 2);
  6512. pps->init_qp= get_se_golomb(&s->gb) + 26;
  6513. pps->init_qs= get_se_golomb(&s->gb) + 26;
  6514. pps->chroma_qp_index_offset= get_se_golomb(&s->gb);
  6515. pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
  6516. pps->constrained_intra_pred= get_bits1(&s->gb);
  6517. pps->redundant_pic_cnt_present = get_bits1(&s->gb);
  6518. memset(pps->scaling_matrix4, 16, 6*16*sizeof(uint8_t));
  6519. memset(pps->scaling_matrix8, 16, 2*64*sizeof(uint8_t));
  6520. if(get_bits_count(&s->gb) < bit_length){
  6521. pps->transform_8x8_mode= get_bits1(&s->gb);
  6522. decode_scaling_matrices(h, &h->sps_buffer[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
  6523. get_se_golomb(&s->gb); //second_chroma_qp_index_offset
  6524. }
  6525. if(s->avctx->debug&FF_DEBUG_PICT_INFO){
  6526. 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",
  6527. pps_id, pps->sps_id,
  6528. pps->cabac ? "CABAC" : "CAVLC",
  6529. pps->slice_group_count,
  6530. pps->ref_count[0], pps->ref_count[1],
  6531. pps->weighted_pred ? "weighted" : "",
  6532. pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset,
  6533. pps->deblocking_filter_parameters_present ? "LPAR" : "",
  6534. pps->constrained_intra_pred ? "CONSTR" : "",
  6535. pps->redundant_pic_cnt_present ? "REDU" : "",
  6536. pps->transform_8x8_mode ? "8x8DCT" : ""
  6537. );
  6538. }
  6539. return 0;
  6540. }
  6541. /**
  6542. * finds the end of the current frame in the bitstream.
  6543. * @return the position of the first byte of the next frame, or -1
  6544. */
  6545. static int find_frame_end(H264Context *h, const uint8_t *buf, int buf_size){
  6546. int i;
  6547. uint32_t state;
  6548. ParseContext *pc = &(h->s.parse_context);
  6549. //printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]);
  6550. // mb_addr= pc->mb_addr - 1;
  6551. state= pc->state;
  6552. for(i=0; i<=buf_size; i++){
  6553. if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){
  6554. tprintf("find_frame_end new startcode = %08x, frame_start_found = %d, pos = %d\n", state, pc->frame_start_found, i);
  6555. if(pc->frame_start_found){
  6556. // If there isn't one more byte in the buffer
  6557. // the test on first_mb_in_slice cannot be done yet
  6558. // do it at next call.
  6559. if (i >= buf_size) break;
  6560. if (buf[i] & 0x80) {
  6561. // first_mb_in_slice is 0, probably the first nal of a new
  6562. // slice
  6563. tprintf("find_frame_end frame_end_found, state = %08x, pos = %d\n", state, i);
  6564. pc->state=-1;
  6565. pc->frame_start_found= 0;
  6566. return i-4;
  6567. }
  6568. }
  6569. pc->frame_start_found = 1;
  6570. }
  6571. if((state&0xFFFFFF1F) == 0x107 || (state&0xFFFFFF1F) == 0x108 || (state&0xFFFFFF1F) == 0x109){
  6572. if(pc->frame_start_found){
  6573. pc->state=-1;
  6574. pc->frame_start_found= 0;
  6575. return i-4;
  6576. }
  6577. }
  6578. if (i<buf_size)
  6579. state= (state<<8) | buf[i];
  6580. }
  6581. pc->state= state;
  6582. return END_NOT_FOUND;
  6583. }
  6584. static int h264_parse(AVCodecParserContext *s,
  6585. AVCodecContext *avctx,
  6586. uint8_t **poutbuf, int *poutbuf_size,
  6587. const uint8_t *buf, int buf_size)
  6588. {
  6589. H264Context *h = s->priv_data;
  6590. ParseContext *pc = &h->s.parse_context;
  6591. int next;
  6592. next= find_frame_end(h, buf, buf_size);
  6593. if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
  6594. *poutbuf = NULL;
  6595. *poutbuf_size = 0;
  6596. return buf_size;
  6597. }
  6598. *poutbuf = (uint8_t *)buf;
  6599. *poutbuf_size = buf_size;
  6600. return next;
  6601. }
  6602. static int h264_split(AVCodecContext *avctx,
  6603. const uint8_t *buf, int buf_size)
  6604. {
  6605. int i;
  6606. uint32_t state = -1;
  6607. int has_sps= 0;
  6608. for(i=0; i<=buf_size; i++){
  6609. if((state&0xFFFFFF1F) == 0x107)
  6610. has_sps=1;
  6611. /* if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){
  6612. }*/
  6613. if((state&0xFFFFFF00) == 0x100 && (state&0xFFFFFF1F) != 0x107 && (state&0xFFFFFF1F) != 0x108 && (state&0xFFFFFF1F) != 0x109){
  6614. if(has_sps){
  6615. while(i>4 && buf[i-5]==0) i--;
  6616. return i-4;
  6617. }
  6618. }
  6619. if (i<buf_size)
  6620. state= (state<<8) | buf[i];
  6621. }
  6622. return 0;
  6623. }
  6624. static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){
  6625. MpegEncContext * const s = &h->s;
  6626. AVCodecContext * const avctx= s->avctx;
  6627. int buf_index=0;
  6628. #if 0
  6629. int i;
  6630. for(i=0; i<50; i++){
  6631. av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]);
  6632. }
  6633. #endif
  6634. h->slice_num = 0;
  6635. s->current_picture_ptr= NULL;
  6636. for(;;){
  6637. int consumed;
  6638. int dst_length;
  6639. int bit_length;
  6640. uint8_t *ptr;
  6641. int i, nalsize = 0;
  6642. if(h->is_avc) {
  6643. if(buf_index >= buf_size) break;
  6644. nalsize = 0;
  6645. for(i = 0; i < h->nal_length_size; i++)
  6646. nalsize = (nalsize << 8) | buf[buf_index++];
  6647. if(nalsize <= 1){
  6648. if(nalsize == 1){
  6649. buf_index++;
  6650. continue;
  6651. }else{
  6652. av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize);
  6653. break;
  6654. }
  6655. }
  6656. } else {
  6657. // start code prefix search
  6658. for(; buf_index + 3 < buf_size; buf_index++){
  6659. // this should allways succeed in the first iteration
  6660. if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1)
  6661. break;
  6662. }
  6663. if(buf_index+3 >= buf_size) break;
  6664. buf_index+=3;
  6665. }
  6666. ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index);
  6667. if(ptr[dst_length - 1] == 0) dst_length--;
  6668. bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1);
  6669. if(s->avctx->debug&FF_DEBUG_STARTCODE){
  6670. 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);
  6671. }
  6672. if (h->is_avc && (nalsize != consumed))
  6673. av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize);
  6674. buf_index += consumed;
  6675. if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME dont discard SEI id
  6676. ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
  6677. continue;
  6678. switch(h->nal_unit_type){
  6679. case NAL_IDR_SLICE:
  6680. idr(h); //FIXME ensure we don't loose some frames if there is reordering
  6681. case NAL_SLICE:
  6682. init_get_bits(&s->gb, ptr, bit_length);
  6683. h->intra_gb_ptr=
  6684. h->inter_gb_ptr= &s->gb;
  6685. s->data_partitioning = 0;
  6686. if(decode_slice_header(h) < 0){
  6687. av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");
  6688. break;
  6689. }
  6690. s->current_picture_ptr->key_frame= (h->nal_unit_type == NAL_IDR_SLICE);
  6691. if(h->redundant_pic_count==0 && s->hurry_up < 5
  6692. && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc)
  6693. && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE)
  6694. && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE)
  6695. && avctx->skip_frame < AVDISCARD_ALL)
  6696. decode_slice(h);
  6697. break;
  6698. case NAL_DPA:
  6699. init_get_bits(&s->gb, ptr, bit_length);
  6700. h->intra_gb_ptr=
  6701. h->inter_gb_ptr= NULL;
  6702. s->data_partitioning = 1;
  6703. if(decode_slice_header(h) < 0){
  6704. av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");
  6705. }
  6706. break;
  6707. case NAL_DPB:
  6708. init_get_bits(&h->intra_gb, ptr, bit_length);
  6709. h->intra_gb_ptr= &h->intra_gb;
  6710. break;
  6711. case NAL_DPC:
  6712. init_get_bits(&h->inter_gb, ptr, bit_length);
  6713. h->inter_gb_ptr= &h->inter_gb;
  6714. if(h->redundant_pic_count==0 && h->intra_gb_ptr && s->data_partitioning
  6715. && s->hurry_up < 5
  6716. && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc)
  6717. && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE)
  6718. && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE)
  6719. && avctx->skip_frame < AVDISCARD_ALL)
  6720. decode_slice(h);
  6721. break;
  6722. case NAL_SEI:
  6723. init_get_bits(&s->gb, ptr, bit_length);
  6724. decode_sei(h);
  6725. break;
  6726. case NAL_SPS:
  6727. init_get_bits(&s->gb, ptr, bit_length);
  6728. decode_seq_parameter_set(h);
  6729. if(s->flags& CODEC_FLAG_LOW_DELAY)
  6730. s->low_delay=1;
  6731. if(avctx->has_b_frames < 2)
  6732. avctx->has_b_frames= !s->low_delay;
  6733. break;
  6734. case NAL_PPS:
  6735. init_get_bits(&s->gb, ptr, bit_length);
  6736. decode_picture_parameter_set(h, bit_length);
  6737. break;
  6738. case NAL_AUD:
  6739. case NAL_END_SEQUENCE:
  6740. case NAL_END_STREAM:
  6741. case NAL_FILLER_DATA:
  6742. case NAL_SPS_EXT:
  6743. case NAL_AUXILIARY_SLICE:
  6744. break;
  6745. default:
  6746. av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type);
  6747. }
  6748. }
  6749. if(!s->current_picture_ptr) return buf_index; //no frame
  6750. s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;
  6751. s->current_picture_ptr->pict_type= s->pict_type;
  6752. h->prev_frame_num_offset= h->frame_num_offset;
  6753. h->prev_frame_num= h->frame_num;
  6754. if(s->current_picture_ptr->reference){
  6755. h->prev_poc_msb= h->poc_msb;
  6756. h->prev_poc_lsb= h->poc_lsb;
  6757. }
  6758. if(s->current_picture_ptr->reference)
  6759. execute_ref_pic_marking(h, h->mmco, h->mmco_index);
  6760. ff_er_frame_end(s);
  6761. MPV_frame_end(s);
  6762. return buf_index;
  6763. }
  6764. /**
  6765. * returns the number of bytes consumed for building the current frame
  6766. */
  6767. static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){
  6768. if(s->flags&CODEC_FLAG_TRUNCATED){
  6769. pos -= s->parse_context.last_index;
  6770. if(pos<0) pos=0; // FIXME remove (unneeded?)
  6771. return pos;
  6772. }else{
  6773. if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
  6774. if(pos+10>buf_size) pos=buf_size; // oops ;)
  6775. return pos;
  6776. }
  6777. }
  6778. static int decode_frame(AVCodecContext *avctx,
  6779. void *data, int *data_size,
  6780. uint8_t *buf, int buf_size)
  6781. {
  6782. H264Context *h = avctx->priv_data;
  6783. MpegEncContext *s = &h->s;
  6784. AVFrame *pict = data;
  6785. int buf_index;
  6786. s->flags= avctx->flags;
  6787. s->flags2= avctx->flags2;
  6788. /* no supplementary picture */
  6789. if (buf_size == 0) {
  6790. return 0;
  6791. }
  6792. if(s->flags&CODEC_FLAG_TRUNCATED){
  6793. int next= find_frame_end(h, buf, buf_size);
  6794. if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 )
  6795. return buf_size;
  6796. //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index);
  6797. }
  6798. if(h->is_avc && !h->got_avcC) {
  6799. int i, cnt, nalsize;
  6800. unsigned char *p = avctx->extradata;
  6801. if(avctx->extradata_size < 7) {
  6802. av_log(avctx, AV_LOG_ERROR, "avcC too short\n");
  6803. return -1;
  6804. }
  6805. if(*p != 1) {
  6806. av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p);
  6807. return -1;
  6808. }
  6809. /* sps and pps in the avcC always have length coded with 2 bytes,
  6810. so put a fake nal_length_size = 2 while parsing them */
  6811. h->nal_length_size = 2;
  6812. // Decode sps from avcC
  6813. cnt = *(p+5) & 0x1f; // Number of sps
  6814. p += 6;
  6815. for (i = 0; i < cnt; i++) {
  6816. nalsize = BE_16(p) + 2;
  6817. if(decode_nal_units(h, p, nalsize) < 0) {
  6818. av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i);
  6819. return -1;
  6820. }
  6821. p += nalsize;
  6822. }
  6823. // Decode pps from avcC
  6824. cnt = *(p++); // Number of pps
  6825. for (i = 0; i < cnt; i++) {
  6826. nalsize = BE_16(p) + 2;
  6827. if(decode_nal_units(h, p, nalsize) != nalsize) {
  6828. av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i);
  6829. return -1;
  6830. }
  6831. p += nalsize;
  6832. }
  6833. // Now store right nal length size, that will be use to parse all other nals
  6834. h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1;
  6835. // Do not reparse avcC
  6836. h->got_avcC = 1;
  6837. }
  6838. if(!h->is_avc && s->avctx->extradata_size && s->picture_number==0){
  6839. if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0)
  6840. return -1;
  6841. }
  6842. buf_index=decode_nal_units(h, buf, buf_size);
  6843. if(buf_index < 0)
  6844. return -1;
  6845. //FIXME do something with unavailable reference frames
  6846. // if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_index, buf_size);
  6847. if(!s->current_picture_ptr){
  6848. av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n");
  6849. return -1;
  6850. }
  6851. {
  6852. Picture *out = s->current_picture_ptr;
  6853. #if 0 //decode order
  6854. *data_size = sizeof(AVFrame);
  6855. #else
  6856. /* Sort B-frames into display order */
  6857. Picture *cur = s->current_picture_ptr;
  6858. Picture *prev = h->delayed_output_pic;
  6859. int out_idx = 0;
  6860. int pics = 0;
  6861. int out_of_order;
  6862. int cross_idr = 0;
  6863. int dropped_frame = 0;
  6864. int i;
  6865. if(h->sps.bitstream_restriction_flag
  6866. && s->avctx->has_b_frames < h->sps.num_reorder_frames){
  6867. s->avctx->has_b_frames = h->sps.num_reorder_frames;
  6868. s->low_delay = 0;
  6869. }
  6870. while(h->delayed_pic[pics]) pics++;
  6871. h->delayed_pic[pics++] = cur;
  6872. if(cur->reference == 0)
  6873. cur->reference = 1;
  6874. for(i=0; h->delayed_pic[i]; i++)
  6875. if(h->delayed_pic[i]->key_frame || h->delayed_pic[i]->poc==0)
  6876. cross_idr = 1;
  6877. out = h->delayed_pic[0];
  6878. for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame; i++)
  6879. if(h->delayed_pic[i]->poc < out->poc){
  6880. out = h->delayed_pic[i];
  6881. out_idx = i;
  6882. }
  6883. out_of_order = !cross_idr && prev && out->poc < prev->poc;
  6884. if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames)
  6885. { }
  6886. else if(prev && pics <= s->avctx->has_b_frames)
  6887. out = prev;
  6888. else if((out_of_order && pics-1 == s->avctx->has_b_frames && pics < 15)
  6889. || (s->low_delay &&
  6890. ((!cross_idr && prev && out->poc > prev->poc + 2)
  6891. || cur->pict_type == B_TYPE)))
  6892. {
  6893. s->low_delay = 0;
  6894. s->avctx->has_b_frames++;
  6895. out = prev;
  6896. }
  6897. else if(out_of_order)
  6898. out = prev;
  6899. if(out_of_order || pics > s->avctx->has_b_frames){
  6900. dropped_frame = (out != h->delayed_pic[out_idx]);
  6901. for(i=out_idx; h->delayed_pic[i]; i++)
  6902. h->delayed_pic[i] = h->delayed_pic[i+1];
  6903. }
  6904. if(prev == out && !dropped_frame)
  6905. *data_size = 0;
  6906. else
  6907. *data_size = sizeof(AVFrame);
  6908. if(prev && prev != out && prev->reference == 1)
  6909. prev->reference = 0;
  6910. h->delayed_output_pic = out;
  6911. #endif
  6912. if(out)
  6913. *pict= *(AVFrame*)out;
  6914. else
  6915. av_log(avctx, AV_LOG_DEBUG, "no picture\n");
  6916. }
  6917. assert(pict->data[0] || !*data_size);
  6918. ff_print_debug_info(s, pict);
  6919. //printf("out %d\n", (int)pict->data[0]);
  6920. #if 0 //?
  6921. /* Return the Picture timestamp as the frame number */
  6922. /* we substract 1 because it is added on utils.c */
  6923. avctx->frame_number = s->picture_number - 1;
  6924. #endif
  6925. return get_consumed_bytes(s, buf_index, buf_size);
  6926. }
  6927. #if 0
  6928. static inline void fill_mb_avail(H264Context *h){
  6929. MpegEncContext * const s = &h->s;
  6930. const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
  6931. if(s->mb_y){
  6932. h->mb_avail[0]= s->mb_x && h->slice_table[mb_xy - s->mb_stride - 1] == h->slice_num;
  6933. h->mb_avail[1]= h->slice_table[mb_xy - s->mb_stride ] == h->slice_num;
  6934. h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num;
  6935. }else{
  6936. h->mb_avail[0]=
  6937. h->mb_avail[1]=
  6938. h->mb_avail[2]= 0;
  6939. }
  6940. h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num;
  6941. h->mb_avail[4]= 1; //FIXME move out
  6942. h->mb_avail[5]= 0; //FIXME move out
  6943. }
  6944. #endif
  6945. #if 0 //selftest
  6946. #define COUNT 8000
  6947. #define SIZE (COUNT*40)
  6948. int main(){
  6949. int i;
  6950. uint8_t temp[SIZE];
  6951. PutBitContext pb;
  6952. GetBitContext gb;
  6953. // int int_temp[10000];
  6954. DSPContext dsp;
  6955. AVCodecContext avctx;
  6956. dsputil_init(&dsp, &avctx);
  6957. init_put_bits(&pb, temp, SIZE);
  6958. printf("testing unsigned exp golomb\n");
  6959. for(i=0; i<COUNT; i++){
  6960. START_TIMER
  6961. set_ue_golomb(&pb, i);
  6962. STOP_TIMER("set_ue_golomb");
  6963. }
  6964. flush_put_bits(&pb);
  6965. init_get_bits(&gb, temp, 8*SIZE);
  6966. for(i=0; i<COUNT; i++){
  6967. int j, s;
  6968. s= show_bits(&gb, 24);
  6969. START_TIMER
  6970. j= get_ue_golomb(&gb);
  6971. if(j != i){
  6972. printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
  6973. // return -1;
  6974. }
  6975. STOP_TIMER("get_ue_golomb");
  6976. }
  6977. init_put_bits(&pb, temp, SIZE);
  6978. printf("testing signed exp golomb\n");
  6979. for(i=0; i<COUNT; i++){
  6980. START_TIMER
  6981. set_se_golomb(&pb, i - COUNT/2);
  6982. STOP_TIMER("set_se_golomb");
  6983. }
  6984. flush_put_bits(&pb);
  6985. init_get_bits(&gb, temp, 8*SIZE);
  6986. for(i=0; i<COUNT; i++){
  6987. int j, s;
  6988. s= show_bits(&gb, 24);
  6989. START_TIMER
  6990. j= get_se_golomb(&gb);
  6991. if(j != i - COUNT/2){
  6992. printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
  6993. // return -1;
  6994. }
  6995. STOP_TIMER("get_se_golomb");
  6996. }
  6997. printf("testing 4x4 (I)DCT\n");
  6998. DCTELEM block[16];
  6999. uint8_t src[16], ref[16];
  7000. uint64_t error= 0, max_error=0;
  7001. for(i=0; i<COUNT; i++){
  7002. int j;
  7003. // printf("%d %d %d\n", r1, r2, (r2-r1)*16);
  7004. for(j=0; j<16; j++){
  7005. ref[j]= random()%255;
  7006. src[j]= random()%255;
  7007. }
  7008. h264_diff_dct_c(block, src, ref, 4);
  7009. //normalize
  7010. for(j=0; j<16; j++){
  7011. // printf("%d ", block[j]);
  7012. block[j]= block[j]*4;
  7013. if(j&1) block[j]= (block[j]*4 + 2)/5;
  7014. if(j&4) block[j]= (block[j]*4 + 2)/5;
  7015. }
  7016. // printf("\n");
  7017. s->dsp.h264_idct_add(ref, block, 4);
  7018. /* for(j=0; j<16; j++){
  7019. printf("%d ", ref[j]);
  7020. }
  7021. printf("\n");*/
  7022. for(j=0; j<16; j++){
  7023. int diff= ABS(src[j] - ref[j]);
  7024. error+= diff*diff;
  7025. max_error= FFMAX(max_error, diff);
  7026. }
  7027. }
  7028. printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error );
  7029. #if 0
  7030. printf("testing quantizer\n");
  7031. for(qp=0; qp<52; qp++){
  7032. for(i=0; i<16; i++)
  7033. src1_block[i]= src2_block[i]= random()%255;
  7034. }
  7035. #endif
  7036. printf("Testing NAL layer\n");
  7037. uint8_t bitstream[COUNT];
  7038. uint8_t nal[COUNT*2];
  7039. H264Context h;
  7040. memset(&h, 0, sizeof(H264Context));
  7041. for(i=0; i<COUNT; i++){
  7042. int zeros= i;
  7043. int nal_length;
  7044. int consumed;
  7045. int out_length;
  7046. uint8_t *out;
  7047. int j;
  7048. for(j=0; j<COUNT; j++){
  7049. bitstream[j]= (random() % 255) + 1;
  7050. }
  7051. for(j=0; j<zeros; j++){
  7052. int pos= random() % COUNT;
  7053. while(bitstream[pos] == 0){
  7054. pos++;
  7055. pos %= COUNT;
  7056. }
  7057. bitstream[pos]=0;
  7058. }
  7059. START_TIMER
  7060. nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2);
  7061. if(nal_length<0){
  7062. printf("encoding failed\n");
  7063. return -1;
  7064. }
  7065. out= decode_nal(&h, nal, &out_length, &consumed, nal_length);
  7066. STOP_TIMER("NAL")
  7067. if(out_length != COUNT){
  7068. printf("incorrect length %d %d\n", out_length, COUNT);
  7069. return -1;
  7070. }
  7071. if(consumed != nal_length){
  7072. printf("incorrect consumed length %d %d\n", nal_length, consumed);
  7073. return -1;
  7074. }
  7075. if(memcmp(bitstream, out, COUNT)){
  7076. printf("missmatch\n");
  7077. return -1;
  7078. }
  7079. }
  7080. printf("Testing RBSP\n");
  7081. return 0;
  7082. }
  7083. #endif
  7084. static int decode_end(AVCodecContext *avctx)
  7085. {
  7086. H264Context *h = avctx->priv_data;
  7087. MpegEncContext *s = &h->s;
  7088. av_freep(&h->rbsp_buffer);
  7089. free_tables(h); //FIXME cleanup init stuff perhaps
  7090. MPV_common_end(s);
  7091. // memset(h, 0, sizeof(H264Context));
  7092. return 0;
  7093. }
  7094. AVCodec h264_decoder = {
  7095. "h264",
  7096. CODEC_TYPE_VIDEO,
  7097. CODEC_ID_H264,
  7098. sizeof(H264Context),
  7099. decode_init,
  7100. NULL,
  7101. decode_end,
  7102. decode_frame,
  7103. /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
  7104. .flush= flush_dpb,
  7105. };
  7106. AVCodecParser h264_parser = {
  7107. { CODEC_ID_H264 },
  7108. sizeof(H264Context),
  7109. NULL,
  7110. h264_parse,
  7111. ff_parse_close,
  7112. h264_split,
  7113. };
  7114. #include "svq3.c"