Mercurial > cgi-bin > hgwebdir.cgi > PR > Applications > VSs > VSs__H264__App

annotate libavcodec/h264_nal.c @ 6:55fb61482128

find changesets by author, revision, files, or words in the commit message
VSs working
author Nina Engelhardt <nengel@mailbox.tu-berlin.de>
date Wed, 06 Mar 2013 14:35:39 +0100
parents
children
rev   line source
nengel@2 1 #include "h264_types.h"
nengel@2 2 #include "h264_data.h"
nengel@2 3
nengel@2 4 #include "golomb.h"
nengel@2 5 #include "h264_sei.h"
nengel@2 6 #include "h264_refs.h"
nengel@2 7 #include "h264_ps.h"
nengel@2 8 #include "h264_pred_mode.h"
nengel@2 9 #include "h264_misc.h"
nengel@2 10
nengel@2 11 static int ff_h264_decode_rbsp_trailing(const uint8_t *src){
nengel@2 12 int v= *src;
nengel@2 13 int r;
nengel@2 14
nengel@2 15 for(r=1; r<9; r++){
nengel@2 16 if(v&1) return r;
nengel@2 17 v>>=1;
nengel@2 18 }
nengel@2 19 return 0;
nengel@2 20 }
nengel@2 21
nengel@2 22 static int pred_weight_table(H264Slice *s, GetBitContext *gb){
nengel@2 23 int luma_def, chroma_def;
nengel@2 24
nengel@2 25 s->use_weight= 0;
nengel@2 26 s->use_weight_chroma= 0;
nengel@2 27 s->luma_log2_weight_denom= get_ue_golomb(gb);
nengel@2 28 s->chroma_log2_weight_denom= get_ue_golomb(gb);
nengel@2 29 luma_def = 1<<s->luma_log2_weight_denom;
nengel@2 30 chroma_def = 1<<s->chroma_log2_weight_denom;
nengel@2 31
nengel@2 32 for(int list=0; list<2; list++){
nengel@2 33 for(int i=0; i<s->ref_count[list]; i++){
nengel@2 34 int luma_weight_flag, chroma_weight_flag;
nengel@2 35
nengel@2 36 luma_weight_flag= get_bits1(gb);
nengel@2 37 if(luma_weight_flag){
nengel@2 38 s->luma_weight[i][list][0]= get_se_golomb(gb);
nengel@2 39 s->luma_weight[i][list][1]= get_se_golomb(gb);
nengel@2 40 if( s->luma_weight[i][list][0] != luma_def
nengel@2 41 || s->luma_weight[i][list][1] != 0) {
nengel@2 42 s->use_weight= 1;
nengel@2 43 }
nengel@2 44 }else{
nengel@2 45 s->luma_weight[i][list][0]= luma_def;
nengel@2 46 s->luma_weight[i][list][1]= 0;
nengel@2 47 }
nengel@2 48
nengel@2 49 chroma_weight_flag= get_bits1(gb);
nengel@2 50 if(chroma_weight_flag){
nengel@2 51 int j;
nengel@2 52 for(j=0; j<2; j++){
nengel@2 53 s->chroma_weight[i][list][j][0]= get_se_golomb(gb);
nengel@2 54 s->chroma_weight[i][list][j][1]= get_se_golomb(gb);
nengel@2 55 if( s->chroma_weight[i][list][j][0] != chroma_def
nengel@2 56 || s->chroma_weight[i][list][j][1] != 0) {
nengel@2 57 s->use_weight_chroma= 1;
nengel@2 58 }
nengel@2 59 }
nengel@2 60 }else{
nengel@2 61 int j;
nengel@2 62 for(j=0; j<2; j++){
nengel@2 63 s->chroma_weight[i][list][j][0]= chroma_def;
nengel@2 64 s->chroma_weight[i][list][j][1]= 0;
nengel@2 65 }
nengel@2 66 }
nengel@2 67 }
nengel@2 68 if(s->slice_type_nos != FF_B_TYPE) break;
nengel@2 69 }
nengel@2 70 s->use_weight= s->use_weight || s->use_weight_chroma;
nengel@2 71 return 0;
nengel@2 72 }
nengel@2 73
nengel@2 74 /**
nengel@2 75 * Initialize implicit_weight table.
nengel@2 76 */
nengel@2 77 static void implicit_weight_table(H264Slice *s){
nengel@2 78 int ref0, ref1, cur_poc, ref_start, ref_count0, ref_count1;
nengel@2 79
nengel@2 80 cur_poc = s->poc;
nengel@2 81 if( s->ref_count[0] == 1 && s->ref_count[1] == 1 && s->ref_list[0][0]->poc + s->ref_list[1][0]->poc == 2*cur_poc){
nengel@2 82 s->use_weight= 0;
nengel@2 83 s->use_weight_chroma= 0;
nengel@2 84 return;
nengel@2 85 }
nengel@2 86 ref_start= 0;
nengel@2 87 ref_count0= s->ref_count[0];
nengel@2 88 ref_count1= s->ref_count[1];
nengel@2 89
nengel@2 90 s->use_weight= 2;
nengel@2 91 s->use_weight_chroma= 2;
nengel@2 92 s->luma_log2_weight_denom= 5;
nengel@2 93 s->chroma_log2_weight_denom= 5;
nengel@2 94
nengel@2 95 for(ref0=ref_start; ref0 < ref_count0; ref0++){
nengel@2 96 int poc0 = s->ref_list[0][ref0]->poc;
nengel@2 97 for(ref1=ref_start; ref1 < ref_count1; ref1++){
nengel@2 98 int poc1 = s->ref_list[1][ref1]->poc;
nengel@2 99 int td = av_clip(poc1 - poc0, -128, 127);
nengel@2 100 int w= 32;
nengel@2 101 if(td){
nengel@2 102 int tb = av_clip(cur_poc - poc0, -128, 127);
nengel@2 103 int tx = (16384 + (FFABS(td) >> 1)) / td;
nengel@2 104 int dist_scale_factor = (tb*tx + 32) >> 8;
nengel@2 105 if(dist_scale_factor >= -64 && dist_scale_factor <= 128)
nengel@2 106 w = 64 - dist_scale_factor;
nengel@2 107 }
nengel@2 108 s->implicit_weight[ref0][ref1][0]=
nengel@2 109 s->implicit_weight[ref0][ref1][1]= w;
nengel@2 110 }
nengel@2 111 }
nengel@2 112 }
nengel@2 113
nengel@2 114 /**
nengel@2 115 * instantaneous decoder refresh.
nengel@2 116 */
nengel@2 117 static void idr(NalContext *n, H264Slice *s){
nengel@2 118 ff_h264_remove_all_refs(n, s);
nengel@2 119 n->prev_frame_num= 0;
nengel@2 120 n->prev_frame_num_offset= 0;
nengel@2 121 n->poc_offset += (n->prev_poc_msb<<16) + n->prev_poc_lsb;
nengel@2 122 n->prev_poc_msb=
nengel@2 123 n->prev_poc_lsb= 0;
nengel@2 124 }
nengel@2 125
nengel@2 126 static int init_poc(NalContext *n, H264Slice *s, GetBitContext *gb){
nengel@2 127 const int max_frame_num= 1<<n->sps.log2_max_frame_num;
nengel@2 128 int frame_poc;
nengel@2 129
nengel@2 130 if(n->sps.poc_type==0){
nengel@2 131 n->poc_lsb= get_bits(gb, n->sps.log2_max_poc_lsb);
nengel@2 132 }
nengel@2 133
nengel@2 134 if(n->sps.poc_type==1 && !n->sps.delta_pic_order_always_zero_flag){
nengel@2 135 n->delta_poc= get_se_golomb(gb);
nengel@2 136 }
nengel@2 137
nengel@2 138 n->frame_num_offset= n->prev_frame_num_offset;
nengel@2 139 if(n->frame_num < n->prev_frame_num)
nengel@2 140 n->frame_num_offset += max_frame_num;
nengel@2 141
nengel@2 142 if(n->sps.poc_type==0){
nengel@2 143 const int max_poc_lsb= 1<<n->sps.log2_max_poc_lsb;
nengel@2 144
nengel@2 145 if(n->poc_lsb < n->prev_poc_lsb && n->prev_poc_lsb - n->poc_lsb >= max_poc_lsb/2)
nengel@2 146 n->poc_msb = n->prev_poc_msb + max_poc_lsb;
nengel@2 147 else if(n->poc_lsb > n->prev_poc_lsb && n->prev_poc_lsb - n->poc_lsb < -max_poc_lsb/2)
nengel@2 148 n->poc_msb = n->prev_poc_msb - max_poc_lsb;
nengel@2 149 else
nengel@2 150 n->poc_msb = n->prev_poc_msb;
nengel@2 151
nengel@2 152 frame_poc = n->poc_msb + n->poc_lsb;
nengel@2 153 }else if(n->sps.poc_type==1){
nengel@2 154 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
nengel@2 155 int i;
nengel@2 156
nengel@2 157 if(n->sps.poc_cycle_length != 0)
nengel@2 158 abs_frame_num = n->frame_num_offset + n->frame_num;
nengel@2 159 else
nengel@2 160 abs_frame_num = 0;
nengel@2 161
nengel@2 162 if(s->nal_ref_idc==0 && abs_frame_num > 0)
nengel@2 163 abs_frame_num--;
nengel@2 164
nengel@2 165 expected_delta_per_poc_cycle = 0;
nengel@2 166 for(i=0; i < n->sps.poc_cycle_length; i++)
nengel@2 167 expected_delta_per_poc_cycle += n->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse
nengel@2 168
nengel@2 169 if(abs_frame_num > 0){
nengel@2 170 int poc_cycle_cnt = (abs_frame_num - 1) / n->sps.poc_cycle_length;
nengel@2 171 int frame_num_in_poc_cycle = (abs_frame_num - 1) % n->sps.poc_cycle_length;
nengel@2 172
nengel@2 173 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
nengel@2 174 for(i = 0; i <= frame_num_in_poc_cycle; i++)
nengel@2 175 expectedpoc = expectedpoc + n->sps.offset_for_ref_frame[ i ];
nengel@2 176 } else
nengel@2 177 expectedpoc = 0;
nengel@2 178 if(s->nal_ref_idc == 0)
nengel@2 179 expectedpoc = expectedpoc + n->sps.offset_for_non_ref_pic;
nengel@2 180 frame_poc = expectedpoc + n->delta_poc;
nengel@2 181 }else{
nengel@2 182 int poc= 2*(n->frame_num_offset + n->frame_num);
nengel@2 183 if(!s->nal_ref_idc)
nengel@2 184 poc--;
nengel@2 185 frame_poc= poc;
nengel@2 186 }
nengel@2 187 s->current_picture_info->poc= s->poc = frame_poc + n->poc_offset;
nengel@2 188 s->coded_pic_num = n->coded_pic_num++;
nengel@2 189
nengel@2 190 return 0;
nengel@2 191 }
nengel@2 192
nengel@2 193 static void ref2frame(NalContext *n, H264Slice *s){
nengel@2 194 for(int j=0; j<s->list_count; j++){
nengel@2 195 int *ref2frm= s->ref2frm[j];
nengel@2 196
nengel@2 197 ref2frm[0]=
nengel@2 198 ref2frm[1]= -1;
nengel@2 199
nengel@2 200 for(int i=0; i<s->ref_count[j]; i++){
nengel@2 201 ref2frm[i+2]= 15;
nengel@2 202 if(s->ref_list[j][i]->cpn >=0){
nengel@2 203 int k;
nengel@2 204 for(k=0; k<n->short_ref_count; k++){
nengel@2 205 if(n->short_ref[k]->cpn == s->ref_list[j][i]->cpn){
nengel@2 206 ref2frm[i+2]= k;
nengel@2 207 break;
nengel@2 208 }
nengel@2 209 }
nengel@2 210 }
nengel@2 211 }
nengel@2 212 }
nengel@2 213 }
nengel@2 214
nengel@2 215 /**
nengel@2 216 * decodes a slice header.
nengel@2 217 * This will also call MPV_common_init() and frame_start() as needed.
nengel@2 218 *
nengel@2 219 * @param h h264context
nengel@2 220 * @param h0 h264 master context (differs from 'h' when doing sliced based parallel decoding)
nengel@2 221 *
nengel@2 222 * @return 0 if okay, <0 if an error occurred, 1 if decoding must not be multithreaded
nengel@2 223 */
nengel@2 224 static int decode_slice_header(NalContext *n, H264Slice *s, GetBitContext *gb){
nengel@2 225 unsigned int first_mb_in_slice;
nengel@2 226 unsigned int pps_id;
nengel@2 227 int num_ref_idx_active_override_flag;
nengel@2 228 unsigned int slice_type, tmp;
nengel@2 229
nengel@2 230 first_mb_in_slice= get_ue_golomb(gb);
nengel@2 231 (void) first_mb_in_slice;
nengel@2 232
nengel@2 233 slice_type= get_ue_golomb_31(gb);
nengel@2 234 if(slice_type > 9){
nengel@2 235 av_log(AV_LOG_ERROR, "slice type too large (%d)\n", s->slice_type);
nengel@2 236 return -1;
nengel@2 237 }
nengel@2 238 if(slice_type > 4)
nengel@2 239 slice_type -= 5;
nengel@2 240
nengel@2 241 slice_type= golomb_to_pict_type[ slice_type ];
nengel@2 242
nengel@2 243 s->slice_type= slice_type;
nengel@2 244 s->slice_type_nos= slice_type & 3;
nengel@2 245 s->current_picture_info->slice_type_nos = s->slice_type_nos;
nengel@2 246 s->current_picture_info->reference= s->nal_ref_idc? 2:0;
nengel@2 247 s->key_frame = s->slice_type == FF_I_TYPE;
nengel@2 248
nengel@2 249 pps_id= get_ue_golomb(gb);
nengel@2 250
nengel@2 251 if(pps_id>=MAX_PPS_COUNT){
nengel@2 252 av_log(AV_LOG_ERROR, "pps_id out of range\n");
nengel@2 253 return -1;
nengel@2 254 }
nengel@2 255 if(!n->pps_buffers[pps_id]) {
nengel@2 256 av_log(AV_LOG_ERROR, "non-existing PPS %u referenced\n", pps_id);
nengel@2 257 return -1;
nengel@2 258 }
nengel@2 259 s->pps= *n->pps_buffers[pps_id];
nengel@2 260
nengel@2 261 if(!n->sps_buffers[s->pps.sps_id]) {
nengel@2 262 av_log(AV_LOG_ERROR, "non-existing SPS %u referenced\n", s->pps.sps_id);
nengel@2 263 return -1;
nengel@2 264 }
nengel@2 265 n->sps = *n->sps_buffers[s->pps.sps_id];
nengel@2 266
nengel@2 267 n->mb_width= n->sps.mb_width;
nengel@2 268 n->mb_height= n->sps.mb_height;
nengel@2 269
nengel@2 270 int chroma444 = (n->sps.chroma_format_idc == 3);
nengel@2 271 n->width = 16*n->mb_width - (2>>chroma444)*FFMIN(n->sps.crop_right, (8<<chroma444)-1);
nengel@2 272 if(n->sps.frame_mbs_only_flag)
nengel@2 273 n->height= 16*n->mb_height - (2>>chroma444)*FFMIN(n->sps.crop_bottom, (8<<chroma444)-1);
nengel@2 274 else
nengel@2 275 n->height= 16*n->mb_height - (4>>chroma444)*FFMIN(n->sps.crop_bottom, (8<<chroma444)-1);
nengel@2 276
nengel@2 277 s->direct_8x8_inference_flag = n->sps.direct_8x8_inference_flag;
nengel@2 278 s->transform_bypass = n->sps.transform_bypass;
nengel@2 279
nengel@2 280 n->frame_num= get_bits(gb, n->sps.log2_max_frame_num);
nengel@2 281 if(n->frame_num != n->prev_frame_num && n->frame_num != (n->prev_frame_num+1)%(1<<n->sps.log2_max_frame_num)){
nengel@2 282 av_log(AV_LOG_ERROR, "unexpected frame_num \n");
nengel@2 283 }
nengel@2 284
nengel@2 285 s->current_picture_info->frame_num= n->frame_num; //FIXME frame_num cleanup
nengel@2 286 n->max_pic_num= 1<< n->sps.log2_max_frame_num;
nengel@2 287
nengel@2 288 if(s->nal_unit_type == NAL_IDR_SLICE){
nengel@2 289 get_ue_golomb(gb); /* idr_pic_id */
nengel@2 290 }
nengel@2 291
nengel@2 292 init_poc(n, s, gb);
nengel@2 293
nengel@2 294 if(s->pps.redundant_pic_cnt_present){
nengel@2 295 n->redundant_pic_count= get_ue_golomb(gb);
nengel@2 296 }
nengel@2 297
nengel@2 298 //set defaults, might be overridden a few lines later
nengel@2 299 s->ref_count[0]= s->pps.ref_count[0];
nengel@2 300 s->ref_count[1]= s->pps.ref_count[1];
nengel@2 301
nengel@2 302 if(s->slice_type_nos != FF_I_TYPE){
nengel@2 303 if(s->slice_type_nos == FF_B_TYPE){
nengel@2 304 s->direct_spatial_mv_pred= get_bits1(gb);
nengel@2 305 }
nengel@2 306 num_ref_idx_active_override_flag= get_bits1(gb);
nengel@2 307
nengel@2 308 if(num_ref_idx_active_override_flag){
nengel@2 309 s->ref_count[0]= get_ue_golomb(gb) + 1;
nengel@2 310 if(s->slice_type_nos==FF_B_TYPE)
nengel@2 311 s->ref_count[1]= get_ue_golomb(gb) + 1;
nengel@2 312
nengel@2 313 if(s->ref_count[0]-1 > 32-1 || s->ref_count[1]-1 > 32-1){
nengel@2 314 av_log(AV_LOG_ERROR, "reference overflow\n");
nengel@2 315 s->ref_count[0]= s->ref_count[1]= 1;
nengel@2 316 return -1;
nengel@2 317 }
nengel@2 318 }
nengel@2 319 if(s->slice_type_nos == FF_B_TYPE)
nengel@2 320 s->list_count= 2;
nengel@2 321 else
nengel@2 322 s->list_count= 1;
nengel@2 323 }else
nengel@2 324 s->list_count= 0;
nengel@2 325
nengel@2 326
nengel@2 327 if(s->slice_type_nos!=FF_I_TYPE){
nengel@2 328 ff_h264_fill_default_ref_list(n, s);
nengel@2 329 ff_h264_decode_ref_pic_list_reordering(n, s, gb);
nengel@2 330 ref2frame(n, s);
nengel@2 331
nengel@2 332 for(int i=0; i<2; i++){
nengel@2 333 for(int j=0; j<s->ref_count[i]; j++){
nengel@2 334 if (s->ref_list[i][j]==NULL || s->ref_list[i][j]->reference < 2) // Don't know why sometimes the ref_count=1 while there are no references
nengel@2 335 s->ref_list_cpn[i][j] = -1;
nengel@2 336 else
nengel@2 337 s->ref_list_cpn[i][j] = s->ref_list[i][j]->cpn;
nengel@2 338 }
nengel@2 339 }
nengel@2 340 }
nengel@2 341
nengel@2 342 if( (s->pps.weighted_pred && s->slice_type_nos == FF_P_TYPE )
nengel@2 343 || (s->pps.weighted_bipred_idc==1 && s->slice_type_nos== FF_B_TYPE ) ){
nengel@2 344 pred_weight_table(s, gb);
nengel@2 345 }
nengel@2 346 else if(s->pps.weighted_bipred_idc==2 && s->slice_type_nos== FF_B_TYPE){
nengel@2 347 implicit_weight_table( s);
nengel@2 348 }else {
nengel@2 349 s->use_weight = 0;
nengel@2 350 }
nengel@2 351
nengel@2 352 if(s->nal_ref_idc){
nengel@2 353 ff_h264_ref_pic_marking(n, s, gb);
nengel@2 354 n->prev_poc_msb= n->poc_msb;
nengel@2 355 n->prev_poc_lsb= n->poc_lsb;
nengel@2 356 }
nengel@2 357
nengel@2 358 n->prev_frame_num_offset= n->frame_num_offset;
nengel@2 359 n->prev_frame_num= n->frame_num;
nengel@2 360
nengel@2 361 if(s->slice_type_nos != FF_B_TYPE){
nengel@2 362 s->ip_id= n->ip_id++;
nengel@2 363 }
nengel@2 364
nengel@2 365 if(s->slice_type_nos==FF_B_TYPE && !s->direct_spatial_mv_pred){
nengel@2 366 ff_h264_direct_dist_scale_factor(s);
nengel@2 367 }
nengel@2 368 ff_h264_direct_ref_list_init(s);
nengel@2 369
nengel@2 370
nengel@2 371 if( s->slice_type_nos != FF_I_TYPE && s->pps.cabac ){
nengel@2 372 tmp = get_ue_golomb_31(gb);
nengel@2 373 if(tmp > 2){
nengel@2 374 av_log(AV_LOG_ERROR, "cabac_init_idc overflow\n");
nengel@2 375 return -1;
nengel@2 376 }
nengel@2 377 s->cabac_init_idc= tmp;
nengel@2 378 }
nengel@2 379
nengel@2 380 tmp = s->pps.init_qp + get_se_golomb(gb);
nengel@2 381 if(tmp>51){
nengel@2 382 av_log(AV_LOG_ERROR, "QP %u out of range\n", tmp);
nengel@2 383 return -1;
nengel@2 384 }
nengel@2 385 s->qscale= tmp;
nengel@2 386
nengel@2 387 //FIXME qscale / qp ... stuff
nengel@2 388 if(s->slice_type == FF_SP_TYPE){
nengel@2 389 get_bits1(gb); /* sp_for_switch_flag */
nengel@2 390 }
nengel@2 391 if(s->slice_type==FF_SP_TYPE || s->slice_type == FF_SI_TYPE){
nengel@2 392 get_se_golomb(gb); /* slice_qs_delta */
nengel@2 393 }
nengel@2 394
nengel@2 395 s->slice_alpha_c0_offset = 52;
nengel@2 396 s->slice_beta_offset = 52;
nengel@2 397 if( s->pps.deblocking_filter_parameters_present ) {
nengel@2 398 tmp= get_ue_golomb_31(gb);
nengel@2 399 if(tmp > 1){
nengel@2 400 av_log(AV_LOG_ERROR, "deblocking_filter_idc %u out of range\n", tmp);
nengel@2 401 return -1;
nengel@2 402 }
nengel@2 403
nengel@2 404 if(tmp < 2)
nengel@2 405 tmp^= 1; // 1<->0
nengel@2 406
nengel@2 407 if( tmp ) {
nengel@2 408 s->slice_alpha_c0_offset += get_se_golomb(gb) << 1;
nengel@2 409 s->slice_beta_offset += get_se_golomb(gb) << 1;
nengel@2 410 if( (unsigned) s->slice_alpha_c0_offset > 104U
nengel@2 411 ||(unsigned) s->slice_beta_offset > 104U){
nengel@2 412 av_log(AV_LOG_ERROR, "deblocking filter parameters %d %d out of range\n", s->slice_alpha_c0_offset, s->slice_beta_offset);
nengel@2 413 return -1;
nengel@2 414 }
nengel@2 415 }
nengel@2 416 }
nengel@2 417
nengel@2 418 s->qp_thresh= 15 + 52 - FFMIN(s->slice_alpha_c0_offset, s->slice_beta_offset) - FFMAX3(0, s->pps.chroma_qp_index_offset[0], s->pps.chroma_qp_index_offset[1]);
nengel@2 419
nengel@2 420 return 0;
nengel@2 421 }
nengel@2 422
nengel@2 423 PictureInfo *get_pib_entry(NalContext *nc, int coded_pic_num){
nengel@2 424 PictureInfo *pic = NULL;
nengel@2 425
nengel@2 426 for(int i=0; i<MAX_REF_PIC_COUNT+1; i++){
nengel@2 427 if(nc->picture[i].reference==0){
nengel@2 428 pic= &nc->picture[i];
nengel@2 429 break;
nengel@2 430 }
nengel@2 431 }
nengel@2 432 pic->cpn = coded_pic_num;
nengel@2 433
nengel@2 434 return pic;
nengel@2 435 }
nengel@2 436
nengel@2 437 int decode_nal_units(NalContext *n, H264Slice *s, GetBitContext *gb1){
nengel@2 438 GetBitContext *gb = gb1;
nengel@2 439 uint8_t *buf = gb1->raw;
nengel@2 440 int buf_size = gb1->buf_size;
nengel@2 441 int next_avc = buf_size;
nengel@2 442 int buf_index=0;
nengel@2 443 uint8_t *dst=NULL;
nengel@2 444 // gb->raw = gb1->raw;
nengel@2 445 // gb->rbsp = NULL;
nengel@2 446 s->release_cnt=0;
nengel@2 447 ff_h264_reset_sei(n);
nengel@2 448
nengel@2 449 s->current_picture_info = get_pib_entry(n, n->coded_pic_num);
nengel@2 450
nengel@2 451 for(;;){
nengel@2 452 int consumed;
nengel@2 453 int dst_length;
nengel@2 454 int bit_length;
nengel@2 455 const uint8_t *ptr;
nengel@2 456 int err;
nengel@2 457
nengel@2 458 if (buf_index >= buf_size){
nengel@2 459 break;
nengel@2 460 } else {
nengel@2 461 // start code prefix search
nengel@2 462 for(; buf_index + 3 < buf_size; buf_index++){
nengel@2 463 // This should always succeed in the first iteration.
nengel@2 464 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1)
nengel@2 465 break;
nengel@2 466 }
nengel@2 467 if(buf_index+3 >= buf_size) break;
nengel@2 468 buf_index+=3;
nengel@2 469 }
nengel@2 470
nengel@2 471 {
nengel@2 472 int length = next_avc - buf_index;
nengel@2 473 int i, si, di;
nengel@2 474 uint8_t *src= buf+buf_index;
nengel@2 475 // src[0]&0x80; //forbidden bit
nengel@2 476 s->nal_ref_idc= src[0]>>5;
nengel@2 477 s->nal_unit_type= src[0]&0x1F;
nengel@2 478
nengel@2 479 src++; length--;
nengel@2 480
nengel@2 481 for(i=0; i+1<length; i+=2){
nengel@2 482 if(src[i]) continue;
nengel@2 483 if(i>0 && src[i-1]==0) i--;
nengel@2 484 if(i+2<length && src[i+1]==0 && src[i+2]<=3){
nengel@2 485 if(src[i+2]!=3){
nengel@2 486 /* startcode, so we must be past the end */
nengel@2 487 length=i;
nengel@2 488 }
nengel@2 489 break;
nengel@2 490 }
nengel@2 491 }
nengel@2 492
nengel@2 493 if(i>=length-1){ //no escaped 0
nengel@2 494 dst_length= length;
nengel@2 495 consumed= length+1; //+1 for the header
nengel@2 496 ptr=src;
nengel@2 497 }else{
nengel@2 498 av_fast_malloc(&gb->rbsp, &gb->rbsp_size, length+FF_INPUT_BUFFER_PADDING_SIZE);
nengel@2 499 dst = gb->rbsp;
nengel@2 500 // if (dst){
nengel@2 501 // av_free(dst);
nengel@2 502 // }
nengel@2 503 // dst = av_malloc(length+FF_INPUT_BUFFER_PADDING_SIZE);
nengel@2 504
nengel@2 505 if (dst == NULL){
nengel@2 506 return -1;
nengel@2 507 }
nengel@2 508
nengel@2 509 //printf("decoding esc\n");
nengel@2 510 memcpy(dst, src, i);
nengel@2 511 si=di=i;
nengel@2 512 while(si+2<length){
nengel@2 513 //remove escapes (very rare 1:2^22)
nengel@2 514 if(src[si+2]>3){
nengel@2 515 dst[di++]= src[si++];
nengel@2 516 dst[di++]= src[si++];
nengel@2 517 }else if(src[si]==0 && src[si+1]==0){
nengel@2 518 if(src[si+2]==3){ //escape
nengel@2 519 dst[di++]= 0;
nengel@2 520 dst[di++]= 0;
nengel@2 521 si+=3;
nengel@2 522 continue;
nengel@2 523 }else //next start code
nengel@2 524 goto nsc;
nengel@2 525 }
nengel@2 526
nengel@2 527 dst[di++]= src[si++];
nengel@2 528 }
nengel@2 529 while(si<length)
nengel@2 530 dst[di++]= src[si++];
nengel@2 531 nsc:
nengel@2 532
nengel@2 533 memset(dst+di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
nengel@2 534
nengel@2 535 dst_length= di;
nengel@2 536 consumed= si + 1;//+1 for the header
nengel@2 537 //FIXME store exact number of bits in the getbitcontext (it is needed for decoding)
nengel@2 538 ptr=dst;
nengel@2 539 // gb->rbsp=ptr;
nengel@2 540 }
nengel@2 541 }
nengel@2 542 if (ptr==NULL || dst_length < 0){
nengel@2 543 return -1;
nengel@2 544 }
nengel@2 545
nengel@2 546 //error prevention, should not touch dst_length
nengel@2 547 while(ptr[dst_length - 1] == 0 && dst_length > 0)
nengel@2 548 dst_length--;
nengel@2 549
nengel@2 550 bit_length= !dst_length ? 0 : (8*dst_length - ff_h264_decode_rbsp_trailing(ptr + dst_length - 1));
nengel@2 551 buf_index += consumed;
nengel@2 552
nengel@2 553 err = 0;
nengel@2 554 init_get_bits(gb, ptr, bit_length);
nengel@2 555 switch(s->nal_unit_type){
nengel@2 556 case NAL_IDR_SLICE:
nengel@2 557 idr(n, s); //FIXME ensure we don't loose some frames if there is reordering
nengel@2 558 case NAL_SLICE:
nengel@2 559 if((err = decode_slice_header(n, s, gb)))
nengel@2 560 break;
nengel@2 561 s->key_frame |= (s->nal_unit_type == NAL_IDR_SLICE) || (n->sei_recovery_frame_cnt >= 0);
nengel@2 562 break;
nengel@2 563 case NAL_DPA:
nengel@2 564 case NAL_DPB:
nengel@2 565 case NAL_DPC:
nengel@2 566 av_log(AV_LOG_ERROR,"no slices/data partitioning support\n");
nengel@2 567 break;
nengel@2 568 case NAL_SEI:
nengel@2 569 ff_h264_decode_sei(n, gb);
nengel@2 570 break;
nengel@2 571 case NAL_SPS:
nengel@2 572 ff_h264_decode_seq_parameter_set(n, gb);
nengel@2 573 break;
nengel@2 574 case NAL_PPS:
nengel@2 575 ff_h264_decode_picture_parameter_set(n, gb, bit_length);
nengel@2 576 break;
nengel@2 577 case NAL_AUD:
nengel@2 578 case NAL_END_SEQUENCE:
nengel@2 579 case NAL_END_STREAM:
nengel@2 580 case NAL_FILLER_DATA:
nengel@2 581 case NAL_SPS_EXT:
nengel@2 582 case NAL_AUXILIARY_SLICE:
nengel@2 583 break;
nengel@2 584 default:
nengel@2 585 av_log(AV_LOG_ERROR, "Unknown NAL code: %d (%d bits)\n", s->nal_unit_type, bit_length);
nengel@2 586 }
nengel@2 587 if (err < 0)
nengel@2 588 av_log(AV_LOG_ERROR, "decode_slice_header error\n");
nengel@2 589
nengel@2 590 }
nengel@2 591
nengel@2 592 return buf_index;
nengel@2 593 }
nengel@2 594
nengel@2 595 NalContext *get_nal_context(int width, int height){
nengel@2 596 const int mb_height = (height + 15) / 16;
nengel@2 597 const int mb_width = (width + 15) / 16;
nengel@2 598 const int mb_stride = ((mb_width+1)/16 + 1) *16; //align mb_stride to 16
nengel@2 599
nengel@2 600 NalContext *nc = av_mallocz(sizeof(NalContext));
nengel@2 601 nc->width = width;
nengel@2 602 nc->height = height;
nengel@2 603 nc->mb_height = mb_height;
nengel@2 604 nc->mb_width = mb_width;
nengel@2 605 nc->b4_stride = mb_width*4 + 1;
nengel@2 606 nc->mb_stride = mb_stride;
nengel@2 607 nc->outputed_poc = INT_MIN;
nengel@2 608
nengel@2 609 for(int i=0; i<16; i++){
nengel@2 610 nc->picture[i].cpn =-1;
nengel@2 611 }
nengel@2 612
nengel@2 613 return nc;
nengel@2 614 }
nengel@2 615
nengel@2 616 void free_nal_context(NalContext *nc){
nengel@2 617 for(int i = 0; i < MAX_SPS_COUNT; i++){
nengel@2 618 if (nc->sps_buffers[i]){
nengel@2 619 av_free( nc->sps_buffers[i]);
nengel@2 620 }
nengel@2 621 }
nengel@2 622 for(int i = 0; i < MAX_PPS_COUNT; i++){
nengel@2 623 if (nc->pps_buffers[i]){
nengel@2 624 av_free( nc->pps_buffers[i]);
nengel@2 625 }
nengel@2 626 }
nengel@2 627 av_free(nc);
nengel@2 628 }