2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
12 #if !defined(WIN32) && CONFIG_OS_SUPPORT == 1
15 #include "onyxd_int.h"
16 #include "vpx_mem/vpx_mem.h"
17 #include "vp8/common/threading.h"
19 #include "vp8/common/loopfilter.h"
20 #include "vp8/common/extend.h"
21 #include "vpx_ports/vpx_timer.h"
22 #include "detokenize.h"
23 #include "vp8/common/reconinter.h"
24 #include "reconintra_mt.h"
25 #if CONFIG_ERROR_CONCEALMENT
26 #include "error_concealment.h"
29 extern void mb_init_dequantizer(VP8D_COMP *pbi, MACROBLOCKD *xd);
30 extern void clamp_mvs(MACROBLOCKD *xd);
31 extern void vp8_build_uvmvs(MACROBLOCKD *x, int fullpixel);
33 #if CONFIG_RUNTIME_CPU_DETECT
34 #define RTCD_VTABLE(x) (&(pbi)->common.rtcd.x)
36 #define RTCD_VTABLE(x) NULL
39 static void setup_decoding_thread_data(VP8D_COMP *pbi, MACROBLOCKD *xd, MB_ROW_DEC *mbrd, int count)
41 VP8_COMMON *const pc = & pbi->common;
44 for (i = 0; i < count; i++)
46 MACROBLOCKD *mbd = &mbrd[i].mbd;
47 #if CONFIG_RUNTIME_CPU_DETECT
50 mbd->subpixel_predict = xd->subpixel_predict;
51 mbd->subpixel_predict8x4 = xd->subpixel_predict8x4;
52 mbd->subpixel_predict8x8 = xd->subpixel_predict8x8;
53 mbd->subpixel_predict16x16 = xd->subpixel_predict16x16;
55 mbd->mode_info_context = pc->mi + pc->mode_info_stride * (i + 1);
56 mbd->mode_info_stride = pc->mode_info_stride;
58 mbd->frame_type = pc->frame_type;
59 mbd->frames_since_golden = pc->frames_since_golden;
60 mbd->frames_till_alt_ref_frame = pc->frames_till_alt_ref_frame;
62 mbd->pre = pc->yv12_fb[pc->lst_fb_idx];
63 mbd->dst = pc->yv12_fb[pc->new_fb_idx];
65 vp8_setup_block_dptrs(mbd);
66 vp8_build_block_doffsets(mbd);
67 mbd->segmentation_enabled = xd->segmentation_enabled;
68 mbd->mb_segement_abs_delta = xd->mb_segement_abs_delta;
69 vpx_memcpy(mbd->segment_feature_data, xd->segment_feature_data, sizeof(xd->segment_feature_data));
71 /*signed char ref_lf_deltas[MAX_REF_LF_DELTAS];*/
72 vpx_memcpy(mbd->ref_lf_deltas, xd->ref_lf_deltas, sizeof(xd->ref_lf_deltas));
73 /*signed char mode_lf_deltas[MAX_MODE_LF_DELTAS];*/
74 vpx_memcpy(mbd->mode_lf_deltas, xd->mode_lf_deltas, sizeof(xd->mode_lf_deltas));
75 /*unsigned char mode_ref_lf_delta_enabled;
76 unsigned char mode_ref_lf_delta_update;*/
77 mbd->mode_ref_lf_delta_enabled = xd->mode_ref_lf_delta_enabled;
78 mbd->mode_ref_lf_delta_update = xd->mode_ref_lf_delta_update;
80 mbd->current_bc = &pbi->bc2;
82 for (j = 0; j < 25; j++)
84 mbd->block[j].dequant = xd->block[j].dequant;
88 for (i=0; i< pc->mb_rows; i++)
89 pbi->mt_current_mb_col[i]=-1;
93 static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, int mb_row, int mb_col)
96 int i, do_clamp = xd->mode_info_context->mbmi.need_to_clamp_mvs;
98 if (xd->mode_info_context->mbmi.mb_skip_coeff)
100 vp8_reset_mb_tokens_context(xd);
104 eobtotal = vp8_decode_mb_tokens(pbi, xd);
107 /* Perform temporary clamping of the MV to be used for prediction */
113 eobtotal |= (xd->mode_info_context->mbmi.mode == B_PRED ||
114 xd->mode_info_context->mbmi.mode == SPLITMV);
117 /* Special case: Force the loopfilter to skip when eobtotal and
118 * mb_skip_coeff are zero.
120 xd->mode_info_context->mbmi.mb_skip_coeff = 1;
122 /*mt_skip_recon_mb(pbi, xd, mb_row, mb_col);*/
123 if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
125 vp8mt_build_intra_predictors_mbuv_s(pbi, xd, mb_row, mb_col);
126 vp8mt_build_intra_predictors_mby_s(pbi, xd, mb_row, mb_col);
130 vp8_build_inter16x16_predictors_mb(xd, xd->dst.y_buffer,
131 xd->dst.u_buffer, xd->dst.v_buffer,
132 xd->dst.y_stride, xd->dst.uv_stride);
137 if (xd->segmentation_enabled)
138 mb_init_dequantizer(pbi, xd);
141 if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
143 vp8mt_build_intra_predictors_mbuv(pbi, xd, mb_row, mb_col);
145 if (xd->mode_info_context->mbmi.mode != B_PRED)
147 vp8mt_build_intra_predictors_mby(pbi, xd, mb_row, mb_col);
149 vp8mt_intra_prediction_down_copy(pbi, xd, mb_row, mb_col);
154 vp8_build_inter_predictors_mb(xd);
157 #if CONFIG_ERROR_CONCEALMENT
158 if (pbi->ec_enabled &&
159 (mb_row * pbi->common.mb_cols + mb_col >= pbi->mvs_corrupt_from_mb ||
160 vp8dx_bool_error(xd->current_bc)))
162 /* MB with corrupt residuals or corrupt mode/motion vectors.
163 * Better to use the predictor as reconstruction.
165 vpx_memset(xd->qcoeff, 0, sizeof(xd->qcoeff));
166 vp8_conceal_corrupt_mb(xd);
171 /* dequantization and idct */
172 if (xd->mode_info_context->mbmi.mode != B_PRED && xd->mode_info_context->mbmi.mode != SPLITMV)
174 BLOCKD *b = &xd->block[24];
175 DEQUANT_INVOKE(&pbi->dequant, block)(b);
177 /* do 2nd order transform on the dc block */
178 if (xd->eobs[24] > 1)
180 IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh16)(&b->dqcoeff[0], b->diff);
181 ((int *)b->qcoeff)[0] = 0;
182 ((int *)b->qcoeff)[1] = 0;
183 ((int *)b->qcoeff)[2] = 0;
184 ((int *)b->qcoeff)[3] = 0;
185 ((int *)b->qcoeff)[4] = 0;
186 ((int *)b->qcoeff)[5] = 0;
187 ((int *)b->qcoeff)[6] = 0;
188 ((int *)b->qcoeff)[7] = 0;
192 IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh1)(&b->dqcoeff[0], b->diff);
193 ((int *)b->qcoeff)[0] = 0;
196 DEQUANT_INVOKE (&pbi->dequant, dc_idct_add_y_block)
197 (xd->qcoeff, xd->block[0].dequant,
198 xd->predictor, xd->dst.y_buffer,
199 xd->dst.y_stride, xd->eobs, xd->block[24].diff);
201 else if (xd->mode_info_context->mbmi.mode == B_PRED)
203 for (i = 0; i < 16; i++)
205 BLOCKD *b = &xd->block[i];
207 vp8mt_predict_intra4x4(pbi, xd, b->bmi.as_mode, b->predictor, mb_row, mb_col, i);
211 DEQUANT_INVOKE(&pbi->dequant, idct_add)
212 (b->qcoeff, b->dequant, b->predictor,
213 *(b->base_dst) + b->dst, 16, b->dst_stride);
217 IDCT_INVOKE(RTCD_VTABLE(idct), idct1_scalar_add)
218 (b->qcoeff[0] * b->dequant[0], b->predictor,
219 *(b->base_dst) + b->dst, 16, b->dst_stride);
220 ((int *)b->qcoeff)[0] = 0;
226 DEQUANT_INVOKE (&pbi->dequant, idct_add_y_block)
227 (xd->qcoeff, xd->block[0].dequant,
228 xd->predictor, xd->dst.y_buffer,
229 xd->dst.y_stride, xd->eobs);
232 DEQUANT_INVOKE (&pbi->dequant, idct_add_uv_block)
233 (xd->qcoeff+16*16, xd->block[16].dequant,
234 xd->predictor+16*16, xd->dst.u_buffer, xd->dst.v_buffer,
235 xd->dst.uv_stride, xd->eobs+16);
239 static THREAD_FUNCTION thread_decoding_proc(void *p_data)
241 int ithread = ((DECODETHREAD_DATA *)p_data)->ithread;
242 VP8D_COMP *pbi = (VP8D_COMP *)(((DECODETHREAD_DATA *)p_data)->ptr1);
243 MB_ROW_DEC *mbrd = (MB_ROW_DEC *)(((DECODETHREAD_DATA *)p_data)->ptr2);
244 ENTROPY_CONTEXT_PLANES mb_row_left_context;
248 if (pbi->b_multithreaded_rd == 0)
251 /*if(WaitForSingleObject(pbi->h_event_start_decoding[ithread], INFINITE) == WAIT_OBJECT_0)*/
252 if (sem_wait(&pbi->h_event_start_decoding[ithread]) == 0)
254 if (pbi->b_multithreaded_rd == 0)
258 VP8_COMMON *pc = &pbi->common;
259 MACROBLOCKD *xd = &mbrd->mbd;
262 int num_part = 1 << pbi->common.multi_token_partition;
263 volatile int *last_row_current_mb_col;
264 int nsync = pbi->sync_range;
266 for (mb_row = ithread+1; mb_row < pc->mb_rows; mb_row += (pbi->decoding_thread_count + 1))
269 int recon_yoffset, recon_uvoffset;
271 int ref_fb_idx = pc->lst_fb_idx;
272 int dst_fb_idx = pc->new_fb_idx;
273 int recon_y_stride = pc->yv12_fb[ref_fb_idx].y_stride;
274 int recon_uv_stride = pc->yv12_fb[ref_fb_idx].uv_stride;
277 loop_filter_info_n *lfi_n = &pc->lf_info;
279 pbi->mb_row_di[ithread].mb_row = mb_row;
280 pbi->mb_row_di[ithread].mbd.current_bc = &pbi->mbc[mb_row%num_part];
282 last_row_current_mb_col = &pbi->mt_current_mb_col[mb_row -1];
284 recon_yoffset = mb_row * recon_y_stride * 16;
285 recon_uvoffset = mb_row * recon_uv_stride * 8;
286 /* reset above block coeffs */
288 xd->above_context = pc->above_context;
289 xd->left_context = &mb_row_left_context;
290 vpx_memset(&mb_row_left_context, 0, sizeof(mb_row_left_context));
291 xd->up_available = (mb_row != 0);
293 xd->mb_to_top_edge = -((mb_row * 16)) << 3;
294 xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3;
296 for (mb_col = 0; mb_col < pc->mb_cols; mb_col++)
298 if ((mb_col & (nsync-1)) == 0)
300 while (mb_col > (*last_row_current_mb_col - nsync) && *last_row_current_mb_col != pc->mb_cols - 1)
307 update_blockd_bmi(xd);
309 /* Distance of MB to the various image edges.
310 * These are specified to 8th pel as they are always
311 * compared to values that are in 1/8th pel units.
313 xd->mb_to_left_edge = -((mb_col * 16) << 3);
314 xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3;
316 #if CONFIG_ERROR_CONCEALMENT
317 if (pbi->ec_enabled &&
318 (xd->mode_info_context->mbmi.ref_frame ==
320 vp8dx_bool_error(xd->current_bc))
322 /* We have an intra block with corrupt coefficients,
323 * better to conceal with an inter block.
324 * Interpolate MVs from neighboring MBs
326 * Note that for the first mb with corrupt residual
327 * in a frame, we might not discover that before
328 * decoding the residual. That happens after this
329 * check, and therefore no inter concealment will be
332 vp8_interpolate_motion(xd,
334 pc->mb_rows, pc->mb_cols,
335 pc->mode_info_stride);
340 xd->dst.y_buffer = pc->yv12_fb[dst_fb_idx].y_buffer + recon_yoffset;
341 xd->dst.u_buffer = pc->yv12_fb[dst_fb_idx].u_buffer + recon_uvoffset;
342 xd->dst.v_buffer = pc->yv12_fb[dst_fb_idx].v_buffer + recon_uvoffset;
344 xd->left_available = (mb_col != 0);
346 /* Select the appropriate reference frame for this MB */
347 if (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)
348 ref_fb_idx = pc->lst_fb_idx;
349 else if (xd->mode_info_context->mbmi.ref_frame == GOLDEN_FRAME)
350 ref_fb_idx = pc->gld_fb_idx;
352 ref_fb_idx = pc->alt_fb_idx;
354 xd->pre.y_buffer = pc->yv12_fb[ref_fb_idx].y_buffer + recon_yoffset;
355 xd->pre.u_buffer = pc->yv12_fb[ref_fb_idx].u_buffer + recon_uvoffset;
356 xd->pre.v_buffer = pc->yv12_fb[ref_fb_idx].v_buffer + recon_uvoffset;
358 vp8_build_uvmvs(xd, pc->full_pixel);
359 decode_macroblock(pbi, xd, mb_row, mb_col);
361 if (pbi->common.filter_level)
363 int skip_lf = (xd->mode_info_context->mbmi.mode != B_PRED &&
364 xd->mode_info_context->mbmi.mode != SPLITMV &&
365 xd->mode_info_context->mbmi.mb_skip_coeff);
367 const int mode_index = lfi_n->mode_lf_lut[xd->mode_info_context->mbmi.mode];
368 const int seg = xd->mode_info_context->mbmi.segment_id;
369 const int ref_frame = xd->mode_info_context->mbmi.ref_frame;
371 filter_level = lfi_n->lvl[seg][ref_frame][mode_index];
373 if( mb_row != pc->mb_rows-1 )
375 /* Save decoded MB last row data for next-row decoding */
376 vpx_memcpy((pbi->mt_yabove_row[mb_row + 1] + 32 + mb_col*16), (xd->dst.y_buffer + 15 * recon_y_stride), 16);
377 vpx_memcpy((pbi->mt_uabove_row[mb_row + 1] + 16 + mb_col*8), (xd->dst.u_buffer + 7 * recon_uv_stride), 8);
378 vpx_memcpy((pbi->mt_vabove_row[mb_row + 1] + 16 + mb_col*8), (xd->dst.v_buffer + 7 * recon_uv_stride), 8);
381 /* save left_col for next MB decoding */
382 if(mb_col != pc->mb_cols-1)
384 MODE_INFO *next = xd->mode_info_context +1;
386 if (next->mbmi.ref_frame == INTRA_FRAME)
388 for (i = 0; i < 16; i++)
389 pbi->mt_yleft_col[mb_row][i] = xd->dst.y_buffer [i* recon_y_stride + 15];
390 for (i = 0; i < 8; i++)
392 pbi->mt_uleft_col[mb_row][i] = xd->dst.u_buffer [i* recon_uv_stride + 7];
393 pbi->mt_vleft_col[mb_row][i] = xd->dst.v_buffer [i* recon_uv_stride + 7];
398 /* loopfilter on this macroblock. */
401 if(pc->filter_type == NORMAL_LOOPFILTER)
403 loop_filter_info lfi;
404 FRAME_TYPE frame_type = pc->frame_type;
405 const int hev_index = lfi_n->hev_thr_lut[frame_type][filter_level];
406 lfi.mblim = lfi_n->mblim[filter_level];
407 lfi.blim = lfi_n->blim[filter_level];
408 lfi.lim = lfi_n->lim[filter_level];
409 lfi.hev_thr = lfi_n->hev_thr[hev_index];
412 LF_INVOKE(&pc->rtcd.loopfilter, normal_mb_v)
413 (xd->dst.y_buffer, xd->dst.u_buffer, xd->dst.v_buffer, recon_y_stride, recon_uv_stride, &lfi);
416 LF_INVOKE(&pc->rtcd.loopfilter, normal_b_v)
417 (xd->dst.y_buffer, xd->dst.u_buffer, xd->dst.v_buffer, recon_y_stride, recon_uv_stride, &lfi);
419 /* don't apply across umv border */
421 LF_INVOKE(&pc->rtcd.loopfilter, normal_mb_h)
422 (xd->dst.y_buffer, xd->dst.u_buffer, xd->dst.v_buffer, recon_y_stride, recon_uv_stride, &lfi);
425 LF_INVOKE(&pc->rtcd.loopfilter, normal_b_h)
426 (xd->dst.y_buffer, xd->dst.u_buffer, xd->dst.v_buffer, recon_y_stride, recon_uv_stride, &lfi);
431 LF_INVOKE(&pc->rtcd.loopfilter, simple_mb_v)
432 (xd->dst.y_buffer, recon_y_stride, lfi_n->mblim[filter_level]);
435 LF_INVOKE(&pc->rtcd.loopfilter, simple_b_v)
436 (xd->dst.y_buffer, recon_y_stride, lfi_n->blim[filter_level]);
438 /* don't apply across umv border */
440 LF_INVOKE(&pc->rtcd.loopfilter, simple_mb_h)
441 (xd->dst.y_buffer, recon_y_stride, lfi_n->mblim[filter_level]);
444 LF_INVOKE(&pc->rtcd.loopfilter, simple_b_h)
445 (xd->dst.y_buffer, recon_y_stride, lfi_n->blim[filter_level]);
454 ++xd->mode_info_context; /* next mb */
458 /*pbi->mb_row_di[ithread].current_mb_col = mb_col;*/
459 pbi->mt_current_mb_col[mb_row] = mb_col;
462 /* adjust to the next row of mbs */
463 if (pbi->common.filter_level)
465 if(mb_row != pc->mb_rows-1)
467 int lasty = pc->yv12_fb[ref_fb_idx].y_width + VP8BORDERINPIXELS;
468 int lastuv = (pc->yv12_fb[ref_fb_idx].y_width>>1) + (VP8BORDERINPIXELS>>1);
470 for (i = 0; i < 4; i++)
472 pbi->mt_yabove_row[mb_row +1][lasty + i] = pbi->mt_yabove_row[mb_row +1][lasty -1];
473 pbi->mt_uabove_row[mb_row +1][lastuv + i] = pbi->mt_uabove_row[mb_row +1][lastuv -1];
474 pbi->mt_vabove_row[mb_row +1][lastuv + i] = pbi->mt_vabove_row[mb_row +1][lastuv -1];
478 vp8_extend_mb_row(&pc->yv12_fb[dst_fb_idx], xd->dst.y_buffer + 16, xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
480 ++xd->mode_info_context; /* skip prediction column */
482 /* since we have multithread */
483 xd->mode_info_context += xd->mode_info_stride * pbi->decoding_thread_count;
487 /* add this to each frame */
488 if ((mbrd->mb_row == pbi->common.mb_rows-1) || ((mbrd->mb_row == pbi->common.mb_rows-2) && (pbi->common.mb_rows % (pbi->decoding_thread_count+1))==1))
490 /*SetEvent(pbi->h_event_end_decoding);*/
491 sem_post(&pbi->h_event_end_decoding);
499 void vp8_decoder_create_threads(VP8D_COMP *pbi)
504 pbi->b_multithreaded_rd = 0;
505 pbi->allocated_decoding_thread_count = 0;
507 /* limit decoding threads to the max number of token partitions */
508 core_count = (pbi->max_threads > 8) ? 8 : pbi->max_threads;
510 /* limit decoding threads to the available cores */
511 if (core_count > pbi->common.processor_core_count)
512 core_count = pbi->common.processor_core_count;
516 pbi->b_multithreaded_rd = 1;
517 pbi->decoding_thread_count = core_count - 1;
519 CHECK_MEM_ERROR(pbi->h_decoding_thread, vpx_malloc(sizeof(pthread_t) * pbi->decoding_thread_count));
520 CHECK_MEM_ERROR(pbi->h_event_start_decoding, vpx_malloc(sizeof(sem_t) * pbi->decoding_thread_count));
521 CHECK_MEM_ERROR(pbi->mb_row_di, vpx_memalign(32, sizeof(MB_ROW_DEC) * pbi->decoding_thread_count));
522 vpx_memset(pbi->mb_row_di, 0, sizeof(MB_ROW_DEC) * pbi->decoding_thread_count);
523 CHECK_MEM_ERROR(pbi->de_thread_data, vpx_malloc(sizeof(DECODETHREAD_DATA) * pbi->decoding_thread_count));
525 for (ithread = 0; ithread < pbi->decoding_thread_count; ithread++)
527 sem_init(&pbi->h_event_start_decoding[ithread], 0, 0);
529 pbi->de_thread_data[ithread].ithread = ithread;
530 pbi->de_thread_data[ithread].ptr1 = (void *)pbi;
531 pbi->de_thread_data[ithread].ptr2 = (void *) &pbi->mb_row_di[ithread];
533 pthread_create(&pbi->h_decoding_thread[ithread], 0, thread_decoding_proc, (&pbi->de_thread_data[ithread]));
536 sem_init(&pbi->h_event_end_decoding, 0, 0);
538 pbi->allocated_decoding_thread_count = pbi->decoding_thread_count;
543 void vp8mt_de_alloc_temp_buffers(VP8D_COMP *pbi, int mb_rows)
547 if (pbi->b_multithreaded_rd)
549 vpx_free(pbi->mt_current_mb_col);
550 pbi->mt_current_mb_col = NULL ;
552 /* Free above_row buffers. */
553 if (pbi->mt_yabove_row)
555 for (i=0; i< mb_rows; i++)
557 vpx_free(pbi->mt_yabove_row[i]);
558 pbi->mt_yabove_row[i] = NULL ;
560 vpx_free(pbi->mt_yabove_row);
561 pbi->mt_yabove_row = NULL ;
564 if (pbi->mt_uabove_row)
566 for (i=0; i< mb_rows; i++)
568 vpx_free(pbi->mt_uabove_row[i]);
569 pbi->mt_uabove_row[i] = NULL ;
571 vpx_free(pbi->mt_uabove_row);
572 pbi->mt_uabove_row = NULL ;
575 if (pbi->mt_vabove_row)
577 for (i=0; i< mb_rows; i++)
579 vpx_free(pbi->mt_vabove_row[i]);
580 pbi->mt_vabove_row[i] = NULL ;
582 vpx_free(pbi->mt_vabove_row);
583 pbi->mt_vabove_row = NULL ;
586 /* Free left_col buffers. */
587 if (pbi->mt_yleft_col)
589 for (i=0; i< mb_rows; i++)
591 vpx_free(pbi->mt_yleft_col[i]);
592 pbi->mt_yleft_col[i] = NULL ;
594 vpx_free(pbi->mt_yleft_col);
595 pbi->mt_yleft_col = NULL ;
598 if (pbi->mt_uleft_col)
600 for (i=0; i< mb_rows; i++)
602 vpx_free(pbi->mt_uleft_col[i]);
603 pbi->mt_uleft_col[i] = NULL ;
605 vpx_free(pbi->mt_uleft_col);
606 pbi->mt_uleft_col = NULL ;
609 if (pbi->mt_vleft_col)
611 for (i=0; i< mb_rows; i++)
613 vpx_free(pbi->mt_vleft_col[i]);
614 pbi->mt_vleft_col[i] = NULL ;
616 vpx_free(pbi->mt_vleft_col);
617 pbi->mt_vleft_col = NULL ;
623 void vp8mt_alloc_temp_buffers(VP8D_COMP *pbi, int width, int prev_mb_rows)
625 VP8_COMMON *const pc = & pbi->common;
629 if (pbi->b_multithreaded_rd)
631 vp8mt_de_alloc_temp_buffers(pbi, prev_mb_rows);
633 /* our internal buffers are always multiples of 16 */
634 if ((width & 0xf) != 0)
635 width += 16 - (width & 0xf);
637 if (width < 640) pbi->sync_range = 1;
638 else if (width <= 1280) pbi->sync_range = 8;
639 else if (width <= 2560) pbi->sync_range =16;
640 else pbi->sync_range = 32;
642 uv_width = width >>1;
644 /* Allocate an int for each mb row. */
645 CHECK_MEM_ERROR(pbi->mt_current_mb_col, vpx_malloc(sizeof(int) * pc->mb_rows));
647 /* Allocate memory for above_row buffers. */
648 CHECK_MEM_ERROR(pbi->mt_yabove_row, vpx_malloc(sizeof(unsigned char *) * pc->mb_rows));
649 for (i=0; i< pc->mb_rows; i++)
650 CHECK_MEM_ERROR(pbi->mt_yabove_row[i], vpx_calloc(sizeof(unsigned char) * (width + (VP8BORDERINPIXELS<<1)), 1));
652 CHECK_MEM_ERROR(pbi->mt_uabove_row, vpx_malloc(sizeof(unsigned char *) * pc->mb_rows));
653 for (i=0; i< pc->mb_rows; i++)
654 CHECK_MEM_ERROR(pbi->mt_uabove_row[i], vpx_calloc(sizeof(unsigned char) * (uv_width + VP8BORDERINPIXELS), 1));
656 CHECK_MEM_ERROR(pbi->mt_vabove_row, vpx_malloc(sizeof(unsigned char *) * pc->mb_rows));
657 for (i=0; i< pc->mb_rows; i++)
658 CHECK_MEM_ERROR(pbi->mt_vabove_row[i], vpx_calloc(sizeof(unsigned char) * (uv_width + VP8BORDERINPIXELS), 1));
660 /* Allocate memory for left_col buffers. */
661 CHECK_MEM_ERROR(pbi->mt_yleft_col, vpx_malloc(sizeof(unsigned char *) * pc->mb_rows));
662 for (i=0; i< pc->mb_rows; i++)
663 CHECK_MEM_ERROR(pbi->mt_yleft_col[i], vpx_calloc(sizeof(unsigned char) * 16, 1));
665 CHECK_MEM_ERROR(pbi->mt_uleft_col, vpx_malloc(sizeof(unsigned char *) * pc->mb_rows));
666 for (i=0; i< pc->mb_rows; i++)
667 CHECK_MEM_ERROR(pbi->mt_uleft_col[i], vpx_calloc(sizeof(unsigned char) * 8, 1));
669 CHECK_MEM_ERROR(pbi->mt_vleft_col, vpx_malloc(sizeof(unsigned char *) * pc->mb_rows));
670 for (i=0; i< pc->mb_rows; i++)
671 CHECK_MEM_ERROR(pbi->mt_vleft_col[i], vpx_calloc(sizeof(unsigned char) * 8, 1));
676 void vp8_decoder_remove_threads(VP8D_COMP *pbi)
678 /* shutdown MB Decoding thread; */
679 if (pbi->b_multithreaded_rd)
683 pbi->b_multithreaded_rd = 0;
685 /* allow all threads to exit */
686 for (i = 0; i < pbi->allocated_decoding_thread_count; i++)
688 sem_post(&pbi->h_event_start_decoding[i]);
689 pthread_join(pbi->h_decoding_thread[i], NULL);
692 for (i = 0; i < pbi->allocated_decoding_thread_count; i++)
694 sem_destroy(&pbi->h_event_start_decoding[i]);
697 sem_destroy(&pbi->h_event_end_decoding);
699 vpx_free(pbi->h_decoding_thread);
700 pbi->h_decoding_thread = NULL;
702 vpx_free(pbi->h_event_start_decoding);
703 pbi->h_event_start_decoding = NULL;
705 vpx_free(pbi->mb_row_di);
706 pbi->mb_row_di = NULL ;
708 vpx_free(pbi->de_thread_data);
709 pbi->de_thread_data = NULL;
713 void vp8mt_decode_mb_rows( VP8D_COMP *pbi, MACROBLOCKD *xd)
716 VP8_COMMON *pc = &pbi->common;
718 int num_part = 1 << pbi->common.multi_token_partition;
720 volatile int *last_row_current_mb_col = NULL;
721 int nsync = pbi->sync_range;
723 int filter_level = pc->filter_level;
724 loop_filter_info_n *lfi_n = &pc->lf_info;
728 /* Set above_row buffer to 127 for decoding first MB row */
729 vpx_memset(pbi->mt_yabove_row[0] + VP8BORDERINPIXELS-1, 127, pc->yv12_fb[pc->lst_fb_idx].y_width + 5);
730 vpx_memset(pbi->mt_uabove_row[0] + (VP8BORDERINPIXELS>>1)-1, 127, (pc->yv12_fb[pc->lst_fb_idx].y_width>>1) +5);
731 vpx_memset(pbi->mt_vabove_row[0] + (VP8BORDERINPIXELS>>1)-1, 127, (pc->yv12_fb[pc->lst_fb_idx].y_width>>1) +5);
733 for (i=1; i<pc->mb_rows; i++)
735 vpx_memset(pbi->mt_yabove_row[i] + VP8BORDERINPIXELS-1, (unsigned char)129, 1);
736 vpx_memset(pbi->mt_uabove_row[i] + (VP8BORDERINPIXELS>>1)-1, (unsigned char)129, 1);
737 vpx_memset(pbi->mt_vabove_row[i] + (VP8BORDERINPIXELS>>1)-1, (unsigned char)129, 1);
740 /* Set left_col to 129 initially */
741 for (i=0; i<pc->mb_rows; i++)
743 vpx_memset(pbi->mt_yleft_col[i], (unsigned char)129, 16);
744 vpx_memset(pbi->mt_uleft_col[i], (unsigned char)129, 8);
745 vpx_memset(pbi->mt_vleft_col[i], (unsigned char)129, 8);
748 /* Initialize the loop filter for this frame. */
749 vp8_loop_filter_frame_init(pc, &pbi->mb, filter_level, pc->sharpness_level);
752 setup_decoding_thread_data(pbi, xd, pbi->mb_row_di, pbi->decoding_thread_count);
754 for (i = 0; i < pbi->decoding_thread_count; i++)
755 sem_post(&pbi->h_event_start_decoding[i]);
757 for (mb_row = 0; mb_row < pc->mb_rows; mb_row += (pbi->decoding_thread_count + 1))
759 xd->current_bc = &pbi->mbc[mb_row%num_part];
761 /* vp8_decode_mb_row(pbi, pc, mb_row, xd); */
764 int recon_yoffset, recon_uvoffset;
766 int ref_fb_idx = pc->lst_fb_idx;
767 int dst_fb_idx = pc->new_fb_idx;
768 int recon_y_stride = pc->yv12_fb[ref_fb_idx].y_stride;
769 int recon_uv_stride = pc->yv12_fb[ref_fb_idx].uv_stride;
771 /* volatile int *last_row_current_mb_col = NULL; */
773 last_row_current_mb_col = &pbi->mt_current_mb_col[mb_row -1];
775 vpx_memset(&pc->left_context, 0, sizeof(pc->left_context));
776 recon_yoffset = mb_row * recon_y_stride * 16;
777 recon_uvoffset = mb_row * recon_uv_stride * 8;
778 /* reset above block coeffs */
780 xd->above_context = pc->above_context;
781 xd->up_available = (mb_row != 0);
783 xd->mb_to_top_edge = -((mb_row * 16)) << 3;
784 xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3;
786 for (mb_col = 0; mb_col < pc->mb_cols; mb_col++)
788 if ( mb_row > 0 && (mb_col & (nsync-1)) == 0){
789 while (mb_col > (*last_row_current_mb_col - nsync) && *last_row_current_mb_col != pc->mb_cols - 1)
796 update_blockd_bmi(xd);
798 /* Distance of MB to the various image edges.
799 * These are specified to 8th pel as they are always compared to
800 * values that are in 1/8th pel units.
802 xd->mb_to_left_edge = -((mb_col * 16) << 3);
803 xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3;
805 #if CONFIG_ERROR_CONCEALMENT
806 if (pbi->ec_enabled &&
807 (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) &&
808 vp8dx_bool_error(xd->current_bc))
810 /* We have an intra block with corrupt coefficients, better
811 * to conceal with an inter block. Interpolate MVs from
814 * Note that for the first mb with corrupt residual in a
815 * frame, we might not discover that before decoding the
816 * residual. That happens after this check, and therefore no
817 * inter concealment will be done.
819 vp8_interpolate_motion(xd,
821 pc->mb_rows, pc->mb_cols,
822 pc->mode_info_stride);
827 xd->dst.y_buffer = pc->yv12_fb[dst_fb_idx].y_buffer + recon_yoffset;
828 xd->dst.u_buffer = pc->yv12_fb[dst_fb_idx].u_buffer + recon_uvoffset;
829 xd->dst.v_buffer = pc->yv12_fb[dst_fb_idx].v_buffer + recon_uvoffset;
831 xd->left_available = (mb_col != 0);
833 /* Select the appropriate reference frame for this MB */
834 if (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)
835 ref_fb_idx = pc->lst_fb_idx;
836 else if (xd->mode_info_context->mbmi.ref_frame == GOLDEN_FRAME)
837 ref_fb_idx = pc->gld_fb_idx;
839 ref_fb_idx = pc->alt_fb_idx;
841 xd->pre.y_buffer = pc->yv12_fb[ref_fb_idx].y_buffer + recon_yoffset;
842 xd->pre.u_buffer = pc->yv12_fb[ref_fb_idx].u_buffer + recon_uvoffset;
843 xd->pre.v_buffer = pc->yv12_fb[ref_fb_idx].v_buffer + recon_uvoffset;
845 if (xd->mode_info_context->mbmi.ref_frame != INTRA_FRAME)
847 /* propagate errors from reference frames */
848 xd->corrupted |= pc->yv12_fb[ref_fb_idx].corrupted;
851 vp8_build_uvmvs(xd, pc->full_pixel);
852 decode_macroblock(pbi, xd, mb_row, mb_col);
854 /* check if the boolean decoder has suffered an error */
855 xd->corrupted |= vp8dx_bool_error(xd->current_bc);
857 if (pbi->common.filter_level)
859 int skip_lf = (xd->mode_info_context->mbmi.mode != B_PRED &&
860 xd->mode_info_context->mbmi.mode != SPLITMV &&
861 xd->mode_info_context->mbmi.mb_skip_coeff);
863 const int mode_index = lfi_n->mode_lf_lut[xd->mode_info_context->mbmi.mode];
864 const int seg = xd->mode_info_context->mbmi.segment_id;
865 const int ref_frame = xd->mode_info_context->mbmi.ref_frame;
867 filter_level = lfi_n->lvl[seg][ref_frame][mode_index];
869 /* Save decoded MB last row data for next-row decoding */
870 if(mb_row != pc->mb_rows-1)
872 vpx_memcpy((pbi->mt_yabove_row[mb_row +1] + 32 + mb_col*16), (xd->dst.y_buffer + 15 * recon_y_stride), 16);
873 vpx_memcpy((pbi->mt_uabove_row[mb_row +1] + 16 + mb_col*8), (xd->dst.u_buffer + 7 * recon_uv_stride), 8);
874 vpx_memcpy((pbi->mt_vabove_row[mb_row +1] + 16 + mb_col*8), (xd->dst.v_buffer + 7 * recon_uv_stride), 8);
877 /* save left_col for next MB decoding */
878 if(mb_col != pc->mb_cols-1)
880 MODE_INFO *next = xd->mode_info_context +1;
882 if (next->mbmi.ref_frame == INTRA_FRAME)
884 for (i = 0; i < 16; i++)
885 pbi->mt_yleft_col[mb_row][i] = xd->dst.y_buffer [i* recon_y_stride + 15];
886 for (i = 0; i < 8; i++)
888 pbi->mt_uleft_col[mb_row][i] = xd->dst.u_buffer [i* recon_uv_stride + 7];
889 pbi->mt_vleft_col[mb_row][i] = xd->dst.v_buffer [i* recon_uv_stride + 7];
894 /* loopfilter on this macroblock. */
897 if(pc->filter_type == NORMAL_LOOPFILTER)
899 loop_filter_info lfi;
900 FRAME_TYPE frame_type = pc->frame_type;
901 const int hev_index = lfi_n->hev_thr_lut[frame_type][filter_level];
902 lfi.mblim = lfi_n->mblim[filter_level];
903 lfi.blim = lfi_n->blim[filter_level];
904 lfi.lim = lfi_n->lim[filter_level];
905 lfi.hev_thr = lfi_n->hev_thr[hev_index];
908 LF_INVOKE(&pc->rtcd.loopfilter, normal_mb_v)
909 (xd->dst.y_buffer, xd->dst.u_buffer, xd->dst.v_buffer, recon_y_stride, recon_uv_stride, &lfi);
912 LF_INVOKE(&pc->rtcd.loopfilter, normal_b_v)
913 (xd->dst.y_buffer, xd->dst.u_buffer, xd->dst.v_buffer, recon_y_stride, recon_uv_stride, &lfi);
915 /* don't apply across umv border */
917 LF_INVOKE(&pc->rtcd.loopfilter, normal_mb_h)
918 (xd->dst.y_buffer, xd->dst.u_buffer, xd->dst.v_buffer, recon_y_stride, recon_uv_stride, &lfi);
921 LF_INVOKE(&pc->rtcd.loopfilter, normal_b_h)
922 (xd->dst.y_buffer, xd->dst.u_buffer, xd->dst.v_buffer, recon_y_stride, recon_uv_stride, &lfi);
927 LF_INVOKE(&pc->rtcd.loopfilter, simple_mb_v)
928 (xd->dst.y_buffer, recon_y_stride, lfi_n->mblim[filter_level]);
931 LF_INVOKE(&pc->rtcd.loopfilter, simple_b_v)
932 (xd->dst.y_buffer, recon_y_stride, lfi_n->blim[filter_level]);
934 /* don't apply across umv border */
936 LF_INVOKE(&pc->rtcd.loopfilter, simple_mb_h)
937 (xd->dst.y_buffer, recon_y_stride, lfi_n->mblim[filter_level]);
940 LF_INVOKE(&pc->rtcd.loopfilter, simple_b_h)
941 (xd->dst.y_buffer, recon_y_stride, lfi_n->blim[filter_level]);
949 ++xd->mode_info_context; /* next mb */
953 pbi->mt_current_mb_col[mb_row] = mb_col;
956 /* adjust to the next row of mbs */
957 if (pbi->common.filter_level)
959 if(mb_row != pc->mb_rows-1)
961 int lasty = pc->yv12_fb[ref_fb_idx].y_width + VP8BORDERINPIXELS;
962 int lastuv = (pc->yv12_fb[ref_fb_idx].y_width>>1) + (VP8BORDERINPIXELS>>1);
964 for (i = 0; i < 4; i++)
966 pbi->mt_yabove_row[mb_row +1][lasty + i] = pbi->mt_yabove_row[mb_row +1][lasty -1];
967 pbi->mt_uabove_row[mb_row +1][lastuv + i] = pbi->mt_uabove_row[mb_row +1][lastuv -1];
968 pbi->mt_vabove_row[mb_row +1][lastuv + i] = pbi->mt_vabove_row[mb_row +1][lastuv -1];
972 vp8_extend_mb_row(&pc->yv12_fb[dst_fb_idx], xd->dst.y_buffer + 16, xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
974 ++xd->mode_info_context; /* skip prediction column */
976 xd->mode_info_context += xd->mode_info_stride * pbi->decoding_thread_count;
979 sem_wait(&pbi->h_event_end_decoding); /* add back for each frame */