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

annotate libavcodec/h264_rec.c @ 9:ea1ba68cf0ed

find changesets by author, revision, files, or words in the commit message
update to match api changes + add sscc produced source
author Nina Engelhardt <nengel@mailbox.tu-berlin.de>
date Wed, 05 Jun 2013 14:43:26 +0200
parents
children
rev   line source
nengel@2 1 #include "config.h"
nengel@2 2
nengel@2 3 #include "dsputil.h"
nengel@2 4 #include "h264_types.h"
nengel@2 5 #include "h264_data.h"
nengel@2 6 #include "h264_mc.h"
nengel@2 7 #include "h264_deblock.h"
nengel@2 8 #include "h264_pred_mode.h"
nengel@2 9 //#undef NDEBUG
nengel@2 10 #include <assert.h>
nengel@2 11
nengel@2 12 void init_mbrec_context(MBRecContext *mrc, MBRecState *mrs, H264Slice *s, int line){
nengel@2 13 DecodedPicture *pic = s->curr_pic;
nengel@2 14 int mb_stride = mrc->mb_stride;
nengel@2 15 int mb_width = mrc->mb_width;
nengel@2 16 mrs->mb_type_top = pic->mb_type + (line -1)*mb_stride;
nengel@2 17 mrs->mb_type = pic->mb_type + line*mb_stride;
nengel@2 18 mrs->ref_index_top[0] = pic->ref_index[0] + 4*(line -1)*mb_stride;
nengel@2 19 mrs->ref_index_top[1] = pic->ref_index[1] + 4*(line -1)*mb_stride;
nengel@2 20 mrs->ref_index[0] = pic->ref_index[0] + 4*line*mb_stride;
nengel@2 21 mrs->ref_index[1] = pic->ref_index[1] + 4*line*mb_stride;
nengel@2 22
nengel@2 23 mrs->motion_val_top[0] = pic->motion_val[0] + 4*mb_width*4*(line-1);
nengel@2 24 mrs->motion_val_top[1] = pic->motion_val[1] + 4*mb_width*4*(line-1);
nengel@2 25 mrs->motion_val[0] = pic->motion_val[0] + 4*mb_width*4*line;
nengel@2 26 mrs->motion_val[1] = pic->motion_val[1] + 4*mb_width*4*line;
nengel@2 27
nengel@2 28 mrs->intra4x4_pred_mode_top = pic->intra4x4_pred_mode + 4*mb_width*(line-1);
nengel@2 29 mrs->intra4x4_pred_mode = pic->intra4x4_pred_mode + 4*mb_width*line;
nengel@2 30
nengel@2 31 mrs->non_zero_count_top = pic->non_zero_count + 8*mb_width*(line-1);
nengel@2 32 mrs->non_zero_count = pic->non_zero_count + 8*mb_width*line;
nengel@2 33
nengel@2 34 if (s->slice_type_nos == FF_B_TYPE){
nengel@2 35 mrs->list1_mb_type = s->dp_ref_list[1][0]->mb_type + line*mb_stride;
nengel@2 36 mrs->list1_ref_index[0] = s->dp_ref_list[1][0]->ref_index[0] + 4*line*mb_stride;
nengel@2 37 mrs->list1_ref_index[1] = s->dp_ref_list[1][0]->ref_index[1] + 4*line*mb_stride;
nengel@2 38 mrs->list1_motion_val[0] = s->dp_ref_list[1][0]->motion_val[0] + 4*mb_width*4*line;
nengel@2 39 mrs->list1_motion_val[1] = s->dp_ref_list[1][0]->motion_val[1] + 4*mb_width*4*line;
nengel@2 40 }
nengel@2 41
nengel@2 42 }
nengel@2 43
nengel@2 44 #if OMPSS
nengel@2 45 static void backup_mb_border(H264Mb *m, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){
nengel@2 46 int i;
nengel@2 47 uint8_t * top_border_y1 = m->top_border;
nengel@2 48 uint8_t * top_border_y2 = m->top_border + 8;
nengel@2 49 uint8_t * top_border_cb = m->top_border + 16;
nengel@2 50 uint8_t * top_border_cr = m->top_border + 24;
nengel@2 51 uint8_t * top_border_next = m->top_border_next;
nengel@2 52
nengel@2 53 src_y -= linesize;
nengel@2 54 src_cb -= uvlinesize;
nengel@2 55 src_cr -= uvlinesize;
nengel@2 56
nengel@2 57 m->left_border[0]= m->top_border[15];
nengel@2 58 for(i=1; i<17 ; i++){
nengel@2 59 m->left_border[i]= src_y[15 + i*linesize];
nengel@2 60 }
nengel@2 61
nengel@2 62 *(uint64_t*)(top_border_y1) = *(uint64_t*)(src_y + 16*linesize);
nengel@2 63 *(uint64_t*)(top_border_next) = *(uint64_t*)(src_y + 16*linesize);
nengel@2 64 *(uint64_t*)(top_border_y2) = *(uint64_t*)(src_y +8+16*linesize);
nengel@2 65
nengel@2 66 m->left_border[17]= m->top_border[16+7];
nengel@2 67 m->left_border[17+9]= m->top_border[24+7];
nengel@2 68 for(i=1; i<9; i++){
nengel@2 69 m->left_border[17 +i]= src_cb[7+i*uvlinesize];
nengel@2 70 m->left_border[17+9+i]= src_cr[7+i*uvlinesize];
nengel@2 71 }
nengel@2 72 *(uint64_t*)(top_border_cb)= *(uint64_t*)(src_cb+8*uvlinesize);
nengel@2 73 *(uint64_t*)(top_border_cr)= *(uint64_t*)(src_cr+8*uvlinesize);
nengel@2 74 }
nengel@2 75
nengel@2 76 static void xchg_mb_border(H264Mb *m, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int xchg){
nengel@2 77 int temp8, i;
nengel@2 78 uint64_t temp64;
nengel@2 79
nengel@2 80 uint8_t * top_border_y1 = m->top_border;
nengel@2 81 uint8_t * top_border_y2 = m->top_border + 8;
nengel@2 82 uint8_t * top_border_cb = m->top_border + 16;
nengel@2 83 uint8_t * top_border_cr = m->top_border + 24;
nengel@2 84 uint8_t * top_border_next = m->top_border_next;
nengel@2 85
nengel@2 86 int deblock_left;
nengel@2 87 int deblock_top;
nengel@2 88
nengel@2 89 deblock_left = (m->mb_x > 0);
nengel@2 90 deblock_top = (m->mb_y > 0);
nengel@2 91
nengel@2 92 src_y -= ( linesize + 1);
nengel@2 93 src_cb -= (uvlinesize + 1);
nengel@2 94 src_cr -= (uvlinesize + 1);
nengel@2 95
nengel@2 96 #define XCHG(a,b,t,xchg)\
nengel@2 97 t= a;\
nengel@2 98 if(xchg)\
nengel@2 99 a= b;\
nengel@2 100 b= t;
nengel@2 101
nengel@2 102 if(deblock_left){
nengel@2 103 for(i = !deblock_top; i<16; i++){
nengel@2 104 XCHG(m->left_border[i], src_y [i* linesize], temp8, xchg);
nengel@2 105 }
nengel@2 106 XCHG(m->left_border[i], src_y [i* linesize], temp8, 1);
nengel@2 107
nengel@2 108 for(i = !deblock_top; i<8; i++){
nengel@2 109 XCHG(m->left_border[17 +i], src_cb[i*uvlinesize], temp8, xchg);
nengel@2 110 XCHG(m->left_border[17+9+i], src_cr[i*uvlinesize], temp8, xchg);
nengel@2 111 }
nengel@2 112 XCHG(m->left_border[17 +i], src_cb[i*uvlinesize], temp8, 1);
nengel@2 113 XCHG(m->left_border[17+9+i], src_cr[i*uvlinesize], temp8, 1);
nengel@2 114 }
nengel@2 115
nengel@2 116 if(deblock_top){
nengel@2 117 XCHG(*(uint64_t*)(top_border_y1) , *(uint64_t*)(src_y +1), temp64, xchg);
nengel@2 118 XCHG(*(uint64_t*)(top_border_y2) , *(uint64_t*)(src_y +9), temp64, 1);
nengel@2 119 XCHG(*(uint64_t*)(top_border_next), *(uint64_t*)(src_y +17), temp64, 1);
nengel@2 120
nengel@2 121 XCHG(*(uint64_t*)(top_border_cb) , *(uint64_t*)(src_cb+1), temp64, 1);
nengel@2 122 XCHG(*(uint64_t*)(top_border_cr) , *(uint64_t*)(src_cr+1), temp64, 1);
nengel@2 123 }
nengel@2 124 }
nengel@2 125 #else
nengel@2 126
nengel@2 127 static void backup_mb_border(MBRecContext *d, H264Mb *m, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){
nengel@2 128 int i;
nengel@2 129 uint8_t* top_border_y = d->top[m->mb_x].unfiltered_y;
nengel@2 130 uint8_t* top_border_cb = d->top[m->mb_x].unfiltered_cb;
nengel@2 131 uint8_t* top_border_cr = d->top[m->mb_x].unfiltered_cr;
nengel@2 132
nengel@2 133 uint8_t* left_border_y = d->left.unfiltered_y;
nengel@2 134 uint8_t* left_border_cb = d->left.unfiltered_cb;
nengel@2 135 uint8_t* left_border_cr = d->left.unfiltered_cr;
nengel@2 136
nengel@2 137 src_y -= linesize;
nengel@2 138 src_cb -= uvlinesize;
nengel@2 139 src_cr -= uvlinesize;
nengel@2 140
nengel@2 141 // There are two lines saved, the line above the top macroblock of a pair,
nengel@2 142 // and the line above the bottom macroblock
nengel@2 143 left_border_y[0] = top_border_y[15];
nengel@2 144 for(i=1; i<17; i++){
nengel@2 145 left_border_y[i] = src_y[15+i* linesize];
nengel@2 146 }
nengel@2 147 *(uint64_t*)(top_border_y ) = *(uint64_t*)(src_y + 16*linesize);
nengel@2 148 *(uint64_t*)(top_border_y +8) = *(uint64_t*)(src_y +8+16*linesize);
nengel@2 149
nengel@2 150 left_border_cb[0] = top_border_cb[7];
nengel@2 151 left_border_cr[0] = top_border_cr[7];
nengel@2 152 for(i=1; i<9; i++){
nengel@2 153 left_border_cb[i] = src_cb[7+i*uvlinesize];
nengel@2 154 left_border_cr[i] = src_cr[7+i*uvlinesize];
nengel@2 155 }
nengel@2 156 *(uint64_t*)(top_border_cb)= *(uint64_t*)(src_cb+8*uvlinesize);
nengel@2 157 *(uint64_t*)(top_border_cr)= *(uint64_t*)(src_cr+8*uvlinesize);
nengel@2 158 }
nengel@2 159
nengel@2 160 static void xchg_mb_border(MBRecContext *d, H264Mb *m, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int xchg){
nengel@2 161
nengel@2 162 int temp8, i;
nengel@2 163 uint64_t temp64;
nengel@2 164 int deblock_left;
nengel@2 165 int deblock_top;
nengel@2 166
nengel@2 167 uint8_t* top_border_y = d->top[m->mb_x].unfiltered_y;
nengel@2 168 uint8_t* top_border_cb = d->top[m->mb_x].unfiltered_cb;
nengel@2 169 uint8_t* top_border_cr = d->top[m->mb_x].unfiltered_cr;
nengel@2 170 uint8_t* top_border_y_next = d->top[m->mb_x +1].unfiltered_y;
nengel@2 171
nengel@2 172 uint8_t* left_border_y = d->left.unfiltered_y;
nengel@2 173 uint8_t* left_border_cb = d->left.unfiltered_cb;
nengel@2 174 uint8_t* left_border_cr = d->left.unfiltered_cr;
nengel@2 175
nengel@2 176 deblock_left = (m->mb_x > 0);
nengel@2 177 deblock_top = (m->mb_y > 0);
nengel@2 178
nengel@2 179 src_y -= ( linesize + 1);
nengel@2 180 src_cb -= (uvlinesize + 1);
nengel@2 181 src_cr -= (uvlinesize + 1);
nengel@2 182
nengel@2 183 #define XCHG(a,b,t,xchg)\
nengel@2 184 t= a;\
nengel@2 185 if(xchg)\
nengel@2 186 a= b;\
nengel@2 187 b= t;
nengel@2 188
nengel@2 189 if(deblock_left){
nengel@2 190 for(i = !deblock_top; i<16; i++){
nengel@2 191 XCHG(left_border_y[i], src_y [i* linesize], temp8, xchg);
nengel@2 192 }
nengel@2 193 XCHG(left_border_y[i], src_y [i* linesize], temp8, 1);
nengel@2 194
nengel@2 195 for(i = !deblock_top; i<8; i++){
nengel@2 196 XCHG(left_border_cb[i], src_cb[i*uvlinesize], temp8, xchg);
nengel@2 197 XCHG(left_border_cr[i], src_cr[i*uvlinesize], temp8, xchg);
nengel@2 198 }
nengel@2 199 XCHG(left_border_cb[i], src_cb[i*uvlinesize], temp8, 1);
nengel@2 200 XCHG(left_border_cr[i], src_cr[i*uvlinesize], temp8, 1);
nengel@2 201 }
nengel@2 202
nengel@2 203 if(deblock_top){
nengel@2 204 XCHG(*(uint64_t*)(top_border_y+0), *(uint64_t*)(src_y +1), temp64, xchg);
nengel@2 205 XCHG(*(uint64_t*)(top_border_y+8), *(uint64_t*)(src_y +9), temp64, 1);
nengel@2 206 if(m->mb_x+1 < d->mb_width){
nengel@2 207 XCHG(*(uint64_t*)(top_border_y_next), *(uint64_t*)(src_y +17), temp64, 1);
nengel@2 208 }
nengel@2 209 XCHG(*(uint64_t*)(top_border_cb), *(uint64_t*)(src_cb+1), temp64, 1);
nengel@2 210 XCHG(*(uint64_t*)(top_border_cr), *(uint64_t*)(src_cr+1), temp64, 1);
nengel@2 211 }
nengel@2 212 }
nengel@2 213
nengel@2 214 #endif
nengel@2 215
nengel@2 216 void h264_decode_mb_internal(MBRecContext *d, MBRecState *mrs, H264Slice *s, H264Mb *m){
nengel@2 217 int i;
nengel@2 218 const int mb_x= m->mb_x;
nengel@2 219 const int mb_y= m->mb_y;
nengel@2 220 int *block_offset = d->block_offset;
nengel@2 221
nengel@2 222 void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
nengel@2 223 void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
nengel@2 224
nengel@2 225 int linesize = d->linesize;
nengel@2 226 int uvlinesize = d->uvlinesize;
nengel@2 227
nengel@2 228 uint8_t *dest_y = s->curr_pic->data[0] + (mb_x + mb_y * linesize ) * 16;
nengel@2 229 uint8_t *dest_cb = s->curr_pic->data[1] + (mb_x + mb_y * uvlinesize) * 8;
nengel@2 230 uint8_t *dest_cr = s->curr_pic->data[2] + (mb_x + mb_y * uvlinesize) * 8;
nengel@2 231
nengel@2 232 pred_motion_mb_rec (d, mrs, s, m);
nengel@2 233
nengel@2 234 const int mb_type= m->mb_type;
nengel@2 235
nengel@2 236 d->dsp.prefetch(dest_y + (m->mb_x&3)*4*linesize + 64, d->linesize, 4);
nengel@2 237 d->dsp.prefetch(dest_cb + (m->mb_x&7)*uvlinesize + 64, dest_cr - dest_cb, 2);
nengel@2 238
nengel@2 239 if(IS_INTRA(mb_type)){
nengel@2 240 #if OMPSS
nengel@2 241 xchg_mb_border(m, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1);
nengel@2 242 #else
nengel@2 243 xchg_mb_border(d, m, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1);
nengel@2 244 #endif
nengel@2 245
nengel@2 246 d->hpc.pred8x8[ m->chroma_pred_mode ](dest_cb, uvlinesize);
nengel@2 247 d->hpc.pred8x8[ m->chroma_pred_mode ](dest_cr, uvlinesize);
nengel@2 248
nengel@2 249 if(IS_INTRA4x4(mb_type)){
nengel@2 250 if(IS_8x8DCT(mb_type)){
nengel@2 251 idct_dc_add = d->hdsp.h264_idct8_dc_add;
nengel@2 252 idct_add = d->hdsp.h264_idct8_add;
nengel@2 253
nengel@2 254 for(i=0; i<16; i+=4){
nengel@2 255 uint8_t * const ptr= dest_y + block_offset[i];
nengel@2 256 const int dir= mrs->intra4x4_pred_mode_cache[ scan8[i] ];
nengel@2 257
nengel@2 258 const int nnz = mrs->non_zero_count_cache[ scan8[i] ];
nengel@2 259 d->hpc.pred8x8l[ dir ](ptr, (mrs->topleft_samples_available<<i)&0x8000,
nengel@2 260 (mrs->topright_samples_available<<i)&0x4000, linesize);
nengel@2 261 if(nnz){
nengel@2 262 if(nnz == 1 && m->mb[i*16])
nengel@2 263 idct_dc_add(ptr, m->mb + i*16, linesize);
nengel@2 264 else
nengel@2 265 idct_add (ptr, m->mb + i*16, linesize);
nengel@2 266 }
nengel@2 267 }
nengel@2 268 }else{
nengel@2 269 idct_dc_add = d->hdsp.h264_idct_dc_add;
nengel@2 270 idct_add = d->hdsp.h264_idct_add;
nengel@2 271
nengel@2 272 for(i=0; i<16; i++){
nengel@2 273 uint8_t * const ptr= dest_y + block_offset[i];
nengel@2 274 const int dir= mrs->intra4x4_pred_mode_cache[ scan8[i] ];
nengel@2 275 uint8_t *topright;
nengel@2 276 int nnz, tr;
nengel@2 277 if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){
nengel@2 278 const int topright_avail= (mrs->topright_samples_available<<i)&0x8000;
nengel@2 279 assert(mb_y || linesize <= block_offset[i]);
nengel@2 280 if(!topright_avail){
nengel@2 281 tr= ptr[3 - linesize]*0x01010101;
nengel@2 282 topright= (uint8_t*) &tr;
nengel@2 283 }else
nengel@2 284 topright= ptr + 4 - linesize;
nengel@2 285 }else
nengel@2 286 topright= NULL;
nengel@2 287
nengel@2 288 d->hpc.pred4x4[ dir ](ptr, topright, linesize);
nengel@2 289 nnz = mrs->non_zero_count_cache[ scan8[i] ];
nengel@2 290 if(nnz){
nengel@2 291 if(nnz == 1 && m->mb[i*16])
nengel@2 292 idct_dc_add(ptr, m->mb + i*16, linesize);
nengel@2 293 else
nengel@2 294 idct_add (ptr, m->mb + i*16, linesize);
nengel@2 295 }
nengel@2 296 }
nengel@2 297 }
nengel@2 298 }else{
nengel@2 299 d->hpc.pred16x16[ m->intra16x16_pred_mode ](dest_y , linesize);
nengel@2 300 }
nengel@2 301 #if OMPSS
nengel@2 302 xchg_mb_border(m, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0);
nengel@2 303 #else
nengel@2 304 xchg_mb_border(d, m, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0);
nengel@2 305 #endif
nengel@2 306 }else {
nengel@2 307 hl_motion(d, mrs, s, m, dest_y, dest_cb, dest_cr,
nengel@2 308 d->hdsp.qpel_put, d->dsp.put_h264_chroma_pixels_tab,
nengel@2 309 d->hdsp.qpel_avg, d->dsp.avg_h264_chroma_pixels_tab,
nengel@2 310 d->hdsp.weight_h264_pixels_tab, d->hdsp.biweight_h264_pixels_tab);
nengel@2 311 }
nengel@2 312
nengel@2 313 if(!IS_INTRA4x4(mb_type)){
nengel@2 314
nengel@2 315 if(IS_INTRA16x16(mb_type)){
nengel@2 316
nengel@2 317 d->hdsp.h264_idct_add16intra(dest_y, block_offset, m->mb, linesize, mrs->non_zero_count_cache);
nengel@2 318
nengel@2 319 }else if(m->cbp&15){
nengel@2 320
nengel@2 321 if(IS_8x8DCT(mb_type)){
nengel@2 322 d->hdsp.h264_idct8_add4(dest_y, block_offset, m->mb, linesize, mrs->non_zero_count_cache);
nengel@2 323 }else{
nengel@2 324 d->hdsp.h264_idct_add16(dest_y, block_offset, m->mb, linesize, mrs->non_zero_count_cache);
nengel@2 325 }
nengel@2 326 }
nengel@2 327 }
nengel@2 328
nengel@2 329 if(m->cbp&0x30){
nengel@2 330 uint8_t *dest[2] = {dest_cb, dest_cr};
nengel@2 331
nengel@2 332 idct_add = d->hdsp.h264_idct_add;
nengel@2 333 idct_dc_add = d->hdsp.h264_idct_dc_add;
nengel@2 334 for(i=16; i<16+8; i++){
nengel@2 335 if(mrs->non_zero_count_cache[ scan8[i] ])
nengel@2 336 idct_add (dest[(i&4)>>2] + block_offset[i], m->mb + i*16, uvlinesize);
nengel@2 337 else if(m->mb[i*16])
nengel@2 338 idct_dc_add(dest[(i&4)>>2] + block_offset[i], m->mb + i*16, uvlinesize);
nengel@2 339 }
nengel@2 340 }
nengel@2 341
nengel@2 342 #if OMPSS
nengel@2 343 backup_mb_border(m, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
nengel@2 344 if (mb_x+1 <d->mb_width){
nengel@2 345 H264Mb *mr = m+1;
nengel@2 346 memcpy(mr->left_border, m->left_border, sizeof(m->left_border));
nengel@2 347 }
nengel@2 348 if (mb_y +1 <d->mb_height){
nengel@2 349 H264Mb *md = m + d->mb_width;
nengel@2 350 memcpy(md->top_border, m->top_border, sizeof(m->top_border));
nengel@2 351 if (mb_x>0){
nengel@2 352 H264Mb *mdl = m + d->mb_width -1;
nengel@2 353 memcpy(mdl->top_border_next, m->top_border_next, sizeof(m->top_border_next));
nengel@2 354 }
nengel@2 355 }
nengel@2 356 #else
nengel@2 357 backup_mb_border(d, m, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
nengel@2 358 if (mb_y +1 <d->mb_height && d->top_next != d->top){
nengel@2 359 memcpy(&d->top_next[mb_x],&d->top[mb_x], sizeof(TopBorder));
nengel@2 360 }
nengel@2 361 #endif
nengel@2 362
nengel@2 363 ff_h264_filter_mb(d, mrs, s, m, dest_y, dest_cb, dest_cr);
nengel@2 364 }
nengel@2 365
nengel@2 366 MBRecContext *get_mbrec_context(H264Context *h){
nengel@2 367 MBRecContext *d = av_mallocz(sizeof(MBRecContext));
nengel@2 368
nengel@2 369 ff_h264dsp_init(&d->hdsp);
nengel@2 370 ff_h264_pred_init(&d->hpc);
nengel@2 371 dsputil_init(&d->dsp);
nengel@2 372
nengel@2 373 #if !OMPSS
nengel@2 374 d->mrs = av_mallocz(sizeof(MBRecState));
nengel@2 375 #endif
nengel@2 376 d->hdsp.qpel_put= d->dsp.put_h264_qpel_pixels_tab;
nengel@2 377 d->hdsp.qpel_avg= d->dsp.avg_h264_qpel_pixels_tab;
nengel@2 378 d->mb_height = h->mb_height;
nengel@2 379 d->mb_width = h->mb_width;
nengel@2 380 d->mb_stride = h->mb_stride;
nengel@2 381 d->b_stride = h->b_stride;
nengel@2 382 d->height = h->height;
nengel@2 383 d->width = h->width;
nengel@2 384 d->linesize = h->width + EDGE_WIDTH*2;
nengel@2 385 d->uvlinesize = d->linesize>>1;
nengel@2 386
nengel@2 387 d->scratchpad_y = av_malloc(d->linesize*16*sizeof(uint8_t));
nengel@2 388 d->scratchpad_cb= av_malloc(d->uvlinesize*8*sizeof(uint8_t));
nengel@2 389 d->scratchpad_cr= av_malloc(d->uvlinesize*8*sizeof(uint8_t));
nengel@2 390
nengel@2 391 for (int i=0; i<16; i++){
nengel@2 392 d->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*d->linesize*((scan8[i] - scan8[0])>>3);
nengel@2 393 }
nengel@2 394 for (int i=0; i<4; i++){
nengel@2 395 d->block_offset[16+i]=
nengel@2 396 d->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*d->uvlinesize*((scan8[i] - scan8[0])>>3);
nengel@2 397 }
nengel@2 398
nengel@2 399
nengel@2 400
nengel@2 401 return d;
nengel@2 402 }
nengel@2 403
nengel@2 404 void free_mbrec_context(MBRecContext *d){
nengel@2 405 #if !OMPSS
nengel@2 406 av_free(d->mrs);
nengel@2 407 #endif
nengel@2 408 av_free(d->scratchpad_y);
nengel@2 409 av_free(d->scratchpad_cb);
nengel@2 410 av_free(d->scratchpad_cr);
nengel@2 411 av_free(d);
nengel@2 412 }