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

annotate libavcodec/h264_refs.c @ 4:96e628866d41

find changesets by author, revision, files, or words in the commit message
naming some tasks to help debugging
author Nina Engelhardt <nengel@mailbox.tu-berlin.de>
date Wed, 19 Dec 2012 15:40:26 +0100
parents
children
rev   line source
nengel@2 1 /*
nengel@2 2 * H.26L/H.264/AVC/JVT/14496-10/... reference picture handling
nengel@2 3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
nengel@2 4 *
nengel@2 5 * This file is part of FFmpeg.
nengel@2 6 *
nengel@2 7 * FFmpeg is free software; you can redistribute it and/or
nengel@2 8 * modify it under the terms of the GNU Lesser General Public
nengel@2 9 * License as published by the Free Software Foundation; either
nengel@2 10 * version 2.1 of the License, or (at your option) any later version.
nengel@2 11 *
nengel@2 12 * FFmpeg is distributed in the hope that it will be useful,
nengel@2 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
nengel@2 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
nengel@2 15 * Lesser General Public License for more details.
nengel@2 16 *
nengel@2 17 * You should have received a copy of the GNU Lesser General Public
nengel@2 18 * License along with FFmpeg; if not, write to the Free Software
nengel@2 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
nengel@2 20 */
nengel@2 21
nengel@2 22 /**
nengel@2 23 * @file
nengel@2 24 * H.264 / AVC / MPEG4 part10 reference picture handling.
nengel@2 25 * @author Michael Niedermayer <michaelni@gmx.at>
nengel@2 26 */
nengel@2 27
nengel@2 28 #include "dsputil.h"
nengel@2 29 #include "h264_types.h"
nengel@2 30 #include "golomb.h"
nengel@2 31
nengel@2 32 //#undef NDEBUG
nengel@2 33 #include <assert.h>
nengel@2 34
nengel@2 35 static int build_def_list(PictureInfo **def, PictureInfo **in, int len, int is_long){
nengel@2 36 int i[2]={0};
nengel@2 37 int index=0;
nengel@2 38
nengel@2 39 while(i[0]<len || i[1]<len){
nengel@2 40 while(i[0]<len && !(in[ i[0] ] && (in[ i[0] ]->reference)))
nengel@2 41 i[0]++;
nengel@2 42 while(i[1]<len && !(in[ i[1] ] && (in[ i[1] ]->reference & 0)))
nengel@2 43 i[1]++;
nengel@2 44 if(i[0] < len){
nengel@2 45 in[ i[0] ]->pic_id= is_long ? i[0] : in[ i[0] ]->frame_num;
nengel@2 46 def[index++]= in[ i[0]++ ];
nengel@2 47 }
nengel@2 48 if(i[1] < len){
nengel@2 49 in[ i[1] ]->pic_id= is_long ? i[1] : in[ i[1] ]->frame_num;
nengel@2 50 def[index++]= in[ i[1]++ ];
nengel@2 51 }
nengel@2 52 }
nengel@2 53
nengel@2 54 return index;
nengel@2 55 }
nengel@2 56
nengel@2 57 static int add_sorted(PictureInfo **sorted, PictureInfo **src, int len, int limit, int dir){
nengel@2 58 int i, best_poc;
nengel@2 59 int out_i= 0;
nengel@2 60
nengel@2 61 for(;;){
nengel@2 62 best_poc= dir ? INT_MIN : INT_MAX;
nengel@2 63
nengel@2 64 for(i=0; i<len; i++){
nengel@2 65 const int poc= src[i]->poc;
nengel@2 66 if(((poc > limit) ^ dir) && ((poc < best_poc) ^ dir)){
nengel@2 67 best_poc= poc;
nengel@2 68 sorted[out_i]= src[i];
nengel@2 69 }
nengel@2 70 }
nengel@2 71 if(best_poc == (dir ? INT_MIN : INT_MAX))
nengel@2 72 break;
nengel@2 73 limit= sorted[out_i++]->poc - dir;
nengel@2 74 }
nengel@2 75 return out_i;
nengel@2 76 }
nengel@2 77
nengel@2 78 int ff_h264_fill_default_ref_list(NalContext *n, H264Slice *s){
nengel@2 79 int i,len;
nengel@2 80
nengel@2 81 if(s->slice_type_nos==FF_B_TYPE){
nengel@2 82 PictureInfo *sorted[32];
nengel@2 83 int cur_poc, list;
nengel@2 84 int lens[2];
nengel@2 85
nengel@2 86 cur_poc= s->poc;
nengel@2 87
nengel@2 88 for(list= 0; list<2; list++){
nengel@2 89 len= add_sorted(sorted, n->short_ref, n->short_ref_count, cur_poc, !list);
nengel@2 90 len+=add_sorted(sorted+len, n->short_ref, n->short_ref_count, cur_poc, list);
nengel@2 91 assert(len<=32);
nengel@2 92 len= build_def_list(s->ref_list[list], sorted, len, 0);
nengel@2 93 len+=build_def_list(s->ref_list[list] +len, n->long_ref, 16 , 1);
nengel@2 94 assert(len<=32);
nengel@2 95
nengel@2 96 for(int i=len; i<s->ref_count[list]; i++)
nengel@2 97 s->ref_list[list][i] = NULL;
nengel@2 98
nengel@2 99 lens[list]= len;
nengel@2 100 }
nengel@2 101
nengel@2 102 if(lens[0] == lens[1] && lens[1] > 1){
nengel@2 103 for(i=0; s->ref_list[0][i]->poc == s->ref_list[1][i]->poc && i<lens[0]; i++);
nengel@2 104
nengel@2 105 if(i == lens[0])
nengel@2 106 FFSWAP(PictureInfo *, s->ref_list[1][0], s->ref_list[1][1]);
nengel@2 107 }
nengel@2 108 }else{
nengel@2 109 len = build_def_list(s->ref_list[0], n->short_ref, n->short_ref_count, 0);
nengel@2 110 len+= build_def_list(s->ref_list[0] +len, n->long_ref, 16, 1);
nengel@2 111 assert(len <= 32);
nengel@2 112 for(i=len; i<s->ref_count[0]; i++)
nengel@2 113 s->ref_list[0][i] = NULL;
nengel@2 114 }
nengel@2 115
nengel@2 116 return 0;
nengel@2 117 }
nengel@2 118
nengel@2 119 /**
nengel@2 120 * print short term list
nengel@2 121 */
nengel@2 122 static void print_short_term(NalContext *n) {
nengel@2 123 av_log(AV_LOG_DEBUG, "short term list:\n");
nengel@2 124 for(int i=0; i<n->short_ref_count; i++){
nengel@2 125 PictureInfo *pic= n->short_ref[i];
nengel@2 126 av_log(AV_LOG_DEBUG, "%d fn:%d poc:%d ref:%d \n", i, pic->frame_num, pic->poc, pic->reference);
nengel@2 127 }
nengel@2 128 }
nengel@2 129
nengel@2 130 /**
nengel@2 131 * print long term list
nengel@2 132 */
nengel@2 133 static void print_long_term(NalContext *n) {
nengel@2 134 uint32_t i;
nengel@2 135
nengel@2 136 av_log(AV_LOG_DEBUG, "long term list:\n");
nengel@2 137 for(i = 0; i < 16; i++){
nengel@2 138 PictureInfo *pic= n->long_ref[i];
nengel@2 139 if (pic) {
nengel@2 140 av_log(AV_LOG_DEBUG, "%d fn:%d poc:%d\n", i, pic->frame_num, pic->poc);
nengel@2 141 }
nengel@2 142 }
nengel@2 143 }
nengel@2 144
nengel@2 145 int ff_h264_decode_ref_pic_list_reordering(NalContext *n, H264Slice *s, GetBitContext *gb){
nengel@2 146 int list, index;
nengel@2 147
nengel@2 148 print_short_term(n);
nengel@2 149 print_long_term(n);
nengel@2 150
nengel@2 151 for(list=0; list<s->list_count; list++){
nengel@2 152
nengel@2 153 if(get_bits1(gb)){
nengel@2 154 int frame_num = n->frame_num;
nengel@2 155 unsigned int abs_diff_pic_num;
nengel@2 156 for(index=0; ; index++){
nengel@2 157 unsigned int reordering_of_pic_nums_idc= get_ue_golomb_31(gb);
nengel@2 158 int i=0;
nengel@2 159 PictureInfo *ref = NULL;
nengel@2 160
nengel@2 161 if(reordering_of_pic_nums_idc==3){
nengel@2 162 break;
nengel@2 163 }
nengel@2 164 if(index >= s->ref_count[list]){
nengel@2 165 av_log(AV_LOG_ERROR, "reference count overflow\n");
nengel@2 166 return -1;
nengel@2 167 }
nengel@2 168
nengel@2 169 if (reordering_of_pic_nums_idc>2){
nengel@2 170 av_log(AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n");
nengel@2 171 return -1;
nengel@2 172 }
nengel@2 173
nengel@2 174 if (reordering_of_pic_nums_idc<2){
nengel@2 175 //av_log(AV_LOG_ERROR, "long term pic not supported\n");
nengel@2 176
nengel@2 177 abs_diff_pic_num= get_ue_golomb(gb) + 1;
nengel@2 178 if(abs_diff_pic_num > (unsigned) n->max_pic_num){
nengel@2 179 av_log(AV_LOG_ERROR, "abs_diff_pic_num overflow\n");
nengel@2 180 return -1;
nengel@2 181 }
nengel@2 182
nengel@2 183 if(reordering_of_pic_nums_idc == 0)
nengel@2 184 frame_num-= abs_diff_pic_num;
nengel@2 185 else
nengel@2 186 frame_num+= abs_diff_pic_num;
nengel@2 187 frame_num &= n->max_pic_num - 1;
nengel@2 188
nengel@2 189 for(i= 0 ; i<n->short_ref_count; i++){
nengel@2 190 ref = n->short_ref[i];
nengel@2 191 if(ref->frame_num == frame_num && ref->reference){
nengel@2 192 break;
nengel@2 193 }
nengel@2 194 }
nengel@2 195 ref->pic_id= frame_num;
nengel@2 196 }else{
nengel@2 197 int long_idx;
nengel@2 198 long_idx= get_ue_golomb(gb); //long_term_pic_idx
nengel@2 199
nengel@2 200 if(long_idx>31){
nengel@2 201 av_log(AV_LOG_ERROR, "long_term_pic_idx overflow\n");
nengel@2 202 return -1;
nengel@2 203 }
nengel@2 204 ref = n->long_ref[long_idx];
nengel@2 205 assert(!(ref && !ref->reference));
nengel@2 206 if(ref && (ref->reference)){
nengel@2 207 ref->pic_id= long_idx;
nengel@2 208 assert(ref->long_ref);
nengel@2 209 }else{
nengel@2 210 av_log(AV_LOG_ERROR, "reference picture missing during reorder\n");
nengel@2 211 }
nengel@2 212 }
nengel@2 213
nengel@2 214 if (i >= n->short_ref_count) {
nengel@2 215 av_log(AV_LOG_ERROR, "reference picture missing during reorder\n");
nengel@2 216 return -1;
nengel@2 217 } else {
nengel@2 218 for(i=index; i+1 <s->ref_count[list]; i++){
nengel@2 219
nengel@2 220 // if(ref->frame_num == s->ref_list[list][i]->frame_num)
nengel@2 221 // break;
nengel@2 222 ///there is probably no need for a separate pic_id and frame_num
nengel@2 223 if (s->ref_list[list][i]){
nengel@2 224
nengel@2 225 if(ref->long_ref == s->ref_list[list][i]->long_ref && ref->pic_id == s->ref_list[list][i]->pic_id)
nengel@2 226 break;
nengel@2 227 }
nengel@2 228 }
nengel@2 229 for(; i > index; i--){
nengel@2 230 s->ref_list[list][i]= s->ref_list[list][i-1];
nengel@2 231 }
nengel@2 232 s->ref_list[list][index]= ref;
nengel@2 233 }
nengel@2 234 }
nengel@2 235 }
nengel@2 236 }
nengel@2 237
nengel@2 238 // //Check if everything went well
nengel@2 239 // for(list=0; list<s->list_count; list++){
nengel@2 240 // //printf("ref_count %d list %d\n", s->ref_count[list], list);
nengel@2 241 // for(index= 0; index < s->ref_count[list]; index++){
nengel@2 242 // //printf("%d\n", s->ref_list[list][index]->pic_id);
nengel@2 243 // if(!s->ref_list[list][index]->data[0]){
nengel@2 244 // av_log(AV_LOG_ERROR, "Missing reference picture\n");
nengel@2 245 // return -1;
nengel@2 246 // }
nengel@2 247 // }
nengel@2 248 // }
nengel@2 249
nengel@2 250 return 0;
nengel@2 251 }
nengel@2 252
nengel@2 253 static PictureInfo *find_short(NalContext *n, int frame_num){
nengel@2 254 int i;
nengel@2 255 for(i=0; i<n->short_ref_count; i++){
nengel@2 256 if(n->short_ref[i]->frame_num == frame_num) {
nengel@2 257 return n->short_ref[i];
nengel@2 258 }
nengel@2 259 }
nengel@2 260 return NULL;
nengel@2 261 }
nengel@2 262
nengel@2 263 static int remove_short(NalContext *n, H264Slice *s, int frame_num, int release){
nengel@2 264 int i;
nengel@2 265
nengel@2 266 for (i=0; i<n->short_ref_count; i++){
nengel@2 267 if (n->short_ref[i]->frame_num == frame_num){
nengel@2 268 if (release){
nengel@2 269 s->release_ref_cpn[s->release_cnt++] = n->short_ref[i]->cpn;
nengel@2 270 n->short_ref[i]->reference &= ~2;
nengel@2 271 }
nengel@2 272 n->short_ref[i] = NULL;
nengel@2 273 if (--n->short_ref_count)
nengel@2 274 memmove(&n->short_ref[i], &n->short_ref[i+1], (n->short_ref_count - i)*sizeof(PictureInfo *));
nengel@2 275 return 0;
nengel@2 276 }
nengel@2 277 }
nengel@2 278 return -1;
nengel@2 279 }
nengel@2 280
nengel@2 281 static void remove_long(NalContext *n, H264Slice *s, int i){
nengel@2 282
nengel@2 283 if (n->long_ref[i]){
nengel@2 284 s->release_ref_cpn[s->release_cnt++] = n->long_ref[i]->cpn;
nengel@2 285 n->long_ref[i]->reference &= ~2;
nengel@2 286 n->long_ref[i]->long_ref = 0;
nengel@2 287 n->long_ref_count--;
nengel@2 288 n->long_ref[i] = NULL;
nengel@2 289 }
nengel@2 290 }
nengel@2 291
nengel@2 292 void ff_h264_remove_all_refs(NalContext *n, H264Slice *s){
nengel@2 293 int i;
nengel@2 294
nengel@2 295 while (n->short_ref[0])
nengel@2 296 remove_short(n, s, n->short_ref[0]->frame_num, 1);
nengel@2 297
nengel@2 298 for(i=0; i<16; i++){
nengel@2 299 remove_long(n, s, i);
nengel@2 300 }
nengel@2 301 assert(n->short_ref_count==0);
nengel@2 302 assert(n->long_ref_count==0);
nengel@2 303 }
nengel@2 304
nengel@2 305 int ff_h264_ref_pic_marking(NalContext *n, H264Slice *s, GetBitContext *gb){
nengel@2 306
nengel@2 307 if(s->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields
nengel@2 308 get_bits1(gb); //get_bits1(gb) -1; //broken link
nengel@2 309 if(get_bits1(gb)){
nengel@2 310 av_log(AV_LOG_ERROR, "MMCO_LONG reference management not supported\n");
nengel@2 311 }
nengel@2 312 }else{
nengel@2 313 if(get_bits1(gb)){ // adaptive_ref_pic_marking_mode_flag
nengel@2 314 int i,j;
nengel@2 315 for(i= 0; i<MAX_MMCO_COUNT; i++) {
nengel@2 316 PictureInfo *pic;
nengel@2 317 int short_pic_num=0;
nengel@2 318 unsigned int long_arg=0;
nengel@2 319 MMCOOpcode opcode= get_ue_golomb_31(gb);
nengel@2 320
nengel@2 321 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){
nengel@2 322 short_pic_num= (n->frame_num - get_ue_golomb(gb) - 1) & (n->max_pic_num - 1);
nengel@2 323 }
nengel@2 324 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){
nengel@2 325 long_arg= get_ue_golomb_31(gb);
nengel@2 326 if(long_arg >= 16){
nengel@2 327 av_log(AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode);
nengel@2 328 return -1;
nengel@2 329 }
nengel@2 330 }
nengel@2 331
nengel@2 332 if(opcode > (unsigned)MMCO_LONG){
nengel@2 333 av_log(AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode);
nengel@2 334 return -1;
nengel@2 335 }
nengel@2 336 if(opcode == MMCO_END)
nengel@2 337 break;
nengel@2 338
nengel@2 339 switch (opcode){
nengel@2 340 case MMCO_SHORT2UNUSED:
nengel@2 341 remove_short(n, s, short_pic_num, 1);
nengel@2 342 break;
nengel@2 343 case MMCO_SHORT2LONG:
nengel@2 344 pic = find_short(n, short_pic_num);
nengel@2 345 if (n->long_ref[long_arg] != pic)
nengel@2 346 remove_long(n, s, long_arg);
nengel@2 347 remove_short(n, s, short_pic_num, 0);
nengel@2 348 n->long_ref[long_arg]= pic;
nengel@2 349 if (pic){
nengel@2 350 pic->long_ref=1;
nengel@2 351 n->long_ref[long_arg]= pic;
nengel@2 352 n->long_ref_count++;
nengel@2 353 }
nengel@2 354 break;
nengel@2 355 case MMCO_LONG2UNUSED:
nengel@2 356 assert(n->long_ref[long_arg]);
nengel@2 357 remove_long(n, s, long_arg);
nengel@2 358 break;
nengel@2 359 case MMCO_SET_MAX_LONG:
nengel@2 360 for(j=long_arg; j<16; j++)
nengel@2 361 remove_long(n, s, j);
nengel@2 362 break;
nengel@2 363 case MMCO_RESET:
nengel@2 364 while(n->short_ref_count)
nengel@2 365 remove_short(n, s, n->short_ref[0]->frame_num, 1);
nengel@2 366
nengel@2 367 for(j=0; j < 16; j++)
nengel@2 368 remove_long(n, s, j);
nengel@2 369
nengel@2 370 s->current_picture_info->poc=
nengel@2 371 s->poc =
nengel@2 372 n->poc_lsb=
nengel@2 373 n->poc_msb=
nengel@2 374 n->frame_num=
nengel@2 375 s->current_picture_info->frame_num= 0;
nengel@2 376 break;
nengel@2 377 case MMCO_END:
nengel@2 378 case MMCO_LONG:
nengel@2 379 break;
nengel@2 380 }
nengel@2 381 }
nengel@2 382 }else{// sliding window ref picture marking
nengel@2 383 if(n->short_ref_count == n->sps.ref_frame_count) {
nengel@2 384 s->release_ref_cpn[s->release_cnt++] = n->short_ref[n->short_ref_count - 1]->cpn;
nengel@2 385 n->short_ref[n->short_ref_count - 1]->reference &= ~2;
nengel@2 386 n->short_ref[ n->short_ref_count - 1 ] =NULL;
nengel@2 387 n->short_ref_count--;
nengel@2 388 }
nengel@2 389 }
nengel@2 390 }
nengel@2 391
nengel@2 392 if(n->short_ref_count)
nengel@2 393 memmove(&n->short_ref[1], &n->short_ref[0], n->short_ref_count*sizeof(PictureInfo *));
nengel@2 394
nengel@2 395 n->short_ref[0]= s->current_picture_info;
nengel@2 396 n->short_ref_count++;
nengel@2 397
nengel@2 398 return 0;
nengel@2 399 }
nengel@2 400
nengel@2 401 static int get_scale_factor(H264Slice *s, int poc, int poc1, int i){
nengel@2 402 int poc0 = s->ref_list[0][i]->poc;
nengel@2 403 int td = av_clip(poc1 - poc0, -128, 127);
nengel@2 404 if(td == 0 || s->ref_list[0][i]->long_ref){
nengel@2 405 return 256;
nengel@2 406 }else{
nengel@2 407 int tb = av_clip(poc - poc0, -128, 127);
nengel@2 408 int tx = (16384 + (FFABS(td) >> 1)) / td;
nengel@2 409 return av_clip((tb*tx + 32) >> 6, -1024, 1023);
nengel@2 410 }
nengel@2 411 }
nengel@2 412
nengel@2 413 void ff_h264_direct_dist_scale_factor(H264Slice *s){
nengel@2 414 const int poc = s->current_picture_info->poc;
nengel@2 415 const int poc1 = s->ref_list[1][0]->poc;
nengel@2 416
nengel@2 417 for(int i=0; i<s->ref_count[0]; i++){
nengel@2 418 s->dist_scale_factor[i] = get_scale_factor(s, poc, poc1, i);
nengel@2 419 }
nengel@2 420 }
nengel@2 421
nengel@2 422 static void fill_colmap(H264Slice *s, int map[2][16], int list){
nengel@2 423 PictureInfo * const ref1 = s->ref_list[1][0];
nengel@2 424 int old_ref, rfield;
nengel@2 425
nengel@2 426 /* bogus; fills in for missing frames */
nengel@2 427 memset(map[list], 0, sizeof(map[list]));
nengel@2 428
nengel@2 429 for(rfield=0; rfield<2; rfield++){
nengel@2 430 for(old_ref=0; old_ref < ref1->ref_count[list]; old_ref++){
nengel@2 431 int poc = ref1->ref_poc[list][old_ref];
nengel@2 432
nengel@2 433 for(int j=0; j<s->ref_count[0]; j++){
nengel@2 434 if(s->ref_list[0][j]->poc == poc){
nengel@2 435 map[list][old_ref] = j;
nengel@2 436 break;
nengel@2 437 }
nengel@2 438 }
nengel@2 439 }
nengel@2 440 }
nengel@2 441 }
nengel@2 442
nengel@2 443 void ff_h264_direct_ref_list_init(H264Slice *s){
nengel@2 444 PictureInfo * const cur = s->current_picture_info;
nengel@2 445 int list;
nengel@2 446
nengel@2 447 for(list=0; list<2; list++){
nengel@2 448 cur->ref_count[list] = s->ref_count[list];
nengel@2 449 for(int j=0; j<s->ref_count[list]; j++){
nengel@2 450 cur->ref_poc[list][j] = s->ref_list[list][j] ? s->ref_list[list][j]->poc : 0;
nengel@2 451 }
nengel@2 452 }
nengel@2 453
nengel@2 454 if(s->slice_type_nos != FF_B_TYPE || s->direct_spatial_mv_pred)
nengel@2 455 return;
nengel@2 456
nengel@2 457 for(list=0; list<2; list++){
nengel@2 458 fill_colmap(s, s->map_col_to_list0, list);
nengel@2 459 }
nengel@2 460 }
nengel@2 461