ethreading.c 21.3 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5
6
 *  that can be found in the LICENSE file in the root of the source
 *  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.
John Koleszar's avatar
John Koleszar committed
9
10
11
 */

#include "onyx_int.h"
John Koleszar's avatar
John Koleszar committed
12
13
14
#include "vp8/common/threading.h"
#include "vp8/common/common.h"
#include "vp8/common/extend.h"
John Koleszar's avatar
John Koleszar committed
15

16
17
#if CONFIG_MULTITHREAD

Attila Nagy's avatar
Attila Nagy committed
18
19
20
21
22
extern int vp8cx_encode_inter_macroblock(VP8_COMP *cpi, MACROBLOCK *x,
                                         TOKENEXTRA **t, int recon_yoffset,
                                         int recon_uvoffset);
extern int vp8cx_encode_intra_macro_block(VP8_COMP *cpi, MACROBLOCK *x,
                                          TOKENEXTRA **t);
John Koleszar's avatar
John Koleszar committed
23
24
25
26
extern void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x);
extern void vp8_build_block_offsets(MACROBLOCK *x);
extern void vp8_setup_block_ptrs(MACROBLOCK *x);

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
extern void loopfilter_frame(VP8_COMP *cpi, VP8_COMMON *cm);

static THREAD_FUNCTION loopfilter_thread(void *p_data)
{
    VP8_COMP *cpi = (VP8_COMP *)(((LPFTHREAD_DATA *)p_data)->ptr1);
    VP8_COMMON *cm = &cpi->common;

    while (1)
    {
        if (cpi->b_multi_threaded == 0)
            break;

        if (sem_wait(&cpi->h_event_start_lpf) == 0)
        {
            if (cpi->b_multi_threaded == FALSE) // we're shutting down
                break;

            loopfilter_frame(cpi, cm);

            sem_post(&cpi->h_event_end_lpf);
        }
    }

    return 0;
}

John Koleszar's avatar
John Koleszar committed
53
54
55
56
static
THREAD_FUNCTION thread_encoding_proc(void *p_data)
{
    int ithread = ((ENCODETHREAD_DATA *)p_data)->ithread;
Attila Nagy's avatar
Attila Nagy committed
57
    VP8_COMP *cpi = (VP8_COMP *)(((ENCODETHREAD_DATA *)p_data)->ptr1);
John Koleszar's avatar
John Koleszar committed
58
    MB_ROW_COMP *mbri = (MB_ROW_COMP *)(((ENCODETHREAD_DATA *)p_data)->ptr2);
59
    ENTROPY_CONTEXT_PLANES mb_row_left_context;
John Koleszar's avatar
John Koleszar committed
60

Attila Nagy's avatar
Attila Nagy committed
61
    const int nsync = cpi->mt_sync_range;
John Koleszar's avatar
John Koleszar committed
62
63
64
65
66
67
68
69
    //printf("Started thread %d\n", ithread);

    while (1)
    {
        if (cpi->b_multi_threaded == 0)
            break;

        //if(WaitForSingleObject(cpi->h_event_mbrencoding[ithread], INFINITE) == WAIT_OBJECT_0)
Attila Nagy's avatar
Attila Nagy committed
70
        if (sem_wait(&cpi->h_event_start_encoding[ithread]) == 0)
John Koleszar's avatar
John Koleszar committed
71
        {
Attila Nagy's avatar
Attila Nagy committed
72
73
74
75
76
77
78
79
80
            VP8_COMMON *cm = &cpi->common;
            int mb_row;
            MACROBLOCK *x = &mbri->mb;
            MACROBLOCKD *xd = &x->e_mbd;
            TOKENEXTRA *tp ;

            int *segment_counts = mbri->segment_counts;
            int *totalrate = &mbri->totalrate;

John Koleszar's avatar
John Koleszar committed
81
82
            if (cpi->b_multi_threaded == FALSE) // we're shutting down
                break;
Attila Nagy's avatar
Attila Nagy committed
83
84

            for (mb_row = ithread + 1; mb_row < cm->mb_rows; mb_row += (cpi->encoding_thread_count + 1))
John Koleszar's avatar
John Koleszar committed
85
86
            {

Attila Nagy's avatar
Attila Nagy committed
87
88
89
90
91
92
93
                int i;
                int recon_yoffset, recon_uvoffset;
                int mb_col;
                int ref_fb_idx = cm->lst_fb_idx;
                int dst_fb_idx = cm->new_fb_idx;
                int recon_y_stride = cm->yv12_fb[ref_fb_idx].y_stride;
                int recon_uv_stride = cm->yv12_fb[ref_fb_idx].uv_stride;
94
                int map_index = (mb_row * cm->mb_cols);
Attila Nagy's avatar
Attila Nagy committed
95
                volatile int *last_row_current_mb_col;
John Koleszar's avatar
John Koleszar committed
96

Attila Nagy's avatar
Attila Nagy committed
97
                tp = cpi->tok + (mb_row * (cm->mb_cols * 16 * 24));
John Koleszar's avatar
John Koleszar committed
98

Attila Nagy's avatar
Attila Nagy committed
99
                last_row_current_mb_col = &cpi->mt_current_mb_col[mb_row - 1];
John Koleszar's avatar
John Koleszar committed
100

Attila Nagy's avatar
Attila Nagy committed
101
102
103
                // reset above block coeffs
                xd->above_context = cm->above_context;
                xd->left_context = &mb_row_left_context;
John Koleszar's avatar
John Koleszar committed
104

Attila Nagy's avatar
Attila Nagy committed
105
                vp8_zero(mb_row_left_context);
John Koleszar's avatar
John Koleszar committed
106

Attila Nagy's avatar
Attila Nagy committed
107
108
109
                xd->up_available = (mb_row != 0);
                recon_yoffset = (mb_row * recon_y_stride * 16);
                recon_uvoffset = (mb_row * recon_uv_stride * 8);
John Koleszar's avatar
John Koleszar committed
110

Attila Nagy's avatar
Attila Nagy committed
111
                cpi->tplist[mb_row].start = tp;
John Koleszar's avatar
John Koleszar committed
112

Attila Nagy's avatar
Attila Nagy committed
113
                //printf("Thread mb_row = %d\n", mb_row);
John Koleszar's avatar
John Koleszar committed
114

115
116
117
                // Set the mb activity pointer to the start of the row.
                x->mb_activity_ptr = &cpi->mb_activity_map[map_index];

Attila Nagy's avatar
Attila Nagy committed
118
119
120
121
122
123
                // for each macroblock col in image
                for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
                {
                    if ((mb_col & (nsync - 1)) == 0)
                    {
                        while (mb_col > (*last_row_current_mb_col - nsync) && *last_row_current_mb_col != cm->mb_cols - 1)
John Koleszar's avatar
John Koleszar committed
124
125
126
127
                        {
                            x86_pause_hint();
                            thread_sleep(0);
                        }
Attila Nagy's avatar
Attila Nagy committed
128
                    }
John Koleszar's avatar
John Koleszar committed
129

Attila Nagy's avatar
Attila Nagy committed
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
                    // Distance of Mb to the various image edges.
                    // These specified to 8th pel as they are always compared to values that are in 1/8th pel units
                    xd->mb_to_left_edge = -((mb_col * 16) << 3);
                    xd->mb_to_right_edge = ((cm->mb_cols - 1 - mb_col) * 16) << 3;
                    xd->mb_to_top_edge = -((mb_row * 16) << 3);
                    xd->mb_to_bottom_edge = ((cm->mb_rows - 1 - mb_row) * 16) << 3;

                    // Set up limit values for motion vectors used to prevent them extending outside the UMV borders
                    x->mv_col_min = -((mb_col * 16) + (VP8BORDERINPIXELS - 16));
                    x->mv_col_max = ((cm->mb_cols - 1 - mb_col) * 16) + (VP8BORDERINPIXELS - 16);
                    x->mv_row_min = -((mb_row * 16) + (VP8BORDERINPIXELS - 16));
                    x->mv_row_max = ((cm->mb_rows - 1 - mb_row) * 16) + (VP8BORDERINPIXELS - 16);

                    xd->dst.y_buffer = cm->yv12_fb[dst_fb_idx].y_buffer + recon_yoffset;
                    xd->dst.u_buffer = cm->yv12_fb[dst_fb_idx].u_buffer + recon_uvoffset;
                    xd->dst.v_buffer = cm->yv12_fb[dst_fb_idx].v_buffer + recon_uvoffset;
                    xd->left_available = (mb_col != 0);

                    x->rddiv = cpi->RDDIV;
                    x->rdmult = cpi->RDMULT;

151
152
153
                    //Copy current mb to a buffer
                    RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer, x->src.y_stride, x->thismb, 16);

Attila Nagy's avatar
Attila Nagy committed
154
                    if (cpi->oxcf.tuning == VP8_TUNE_SSIM)
155
                        vp8_activity_masking(cpi, x);
Attila Nagy's avatar
Attila Nagy committed
156
157
158
159
160
161

                    // Is segmentation enabled
                    // MB level adjutment to quantizer
                    if (xd->segmentation_enabled)
                    {
                        // Code to set segment id in xd->mbmi.segment_id for current MB (with range checking)
162
163
                        if (cpi->segmentation_map[map_index + mb_col] <= 3)
                            xd->mode_info_context->mbmi.segment_id = cpi->segmentation_map[map_index + mb_col];
John Koleszar's avatar
John Koleszar committed
164
                        else
Attila Nagy's avatar
Attila Nagy committed
165
                            xd->mode_info_context->mbmi.segment_id = 0;
John Koleszar's avatar
John Koleszar committed
166

Attila Nagy's avatar
Attila Nagy committed
167
168
169
170
                        vp8cx_mb_init_quantizer(cpi, x);
                    }
                    else
                        xd->mode_info_context->mbmi.segment_id = 0; // Set to Segment 0 by default
John Koleszar's avatar
John Koleszar committed
171

172
                    x->active_ptr = cpi->active_map + map_index + mb_col;
Attila Nagy's avatar
Attila Nagy committed
173
174
175
176

                    if (cm->frame_type == KEY_FRAME)
                    {
                        *totalrate += vp8cx_encode_intra_macro_block(cpi, x, &tp);
John Koleszar's avatar
John Koleszar committed
177
#ifdef MODE_STATS
Attila Nagy's avatar
Attila Nagy committed
178
                        y_modes[xd->mbmi.mode] ++;
John Koleszar's avatar
John Koleszar committed
179
#endif
Attila Nagy's avatar
Attila Nagy committed
180
181
182
183
                    }
                    else
                    {
                        *totalrate += vp8cx_encode_inter_macroblock(cpi, x, &tp, recon_yoffset, recon_uvoffset);
John Koleszar's avatar
John Koleszar committed
184
185

#ifdef MODE_STATS
Attila Nagy's avatar
Attila Nagy committed
186
                        inter_y_modes[xd->mbmi.mode] ++;
John Koleszar's avatar
John Koleszar committed
187

Attila Nagy's avatar
Attila Nagy committed
188
189
190
                        if (xd->mbmi.mode == SPLITMV)
                        {
                            int b;
John Koleszar's avatar
John Koleszar committed
191

Attila Nagy's avatar
Attila Nagy committed
192
193
194
                            for (b = 0; b < xd->mbmi.partition_count; b++)
                            {
                                inter_b_modes[x->partition->bmi[b].mode] ++;
John Koleszar's avatar
John Koleszar committed
195
                            }
Attila Nagy's avatar
Attila Nagy committed
196
                        }
John Koleszar's avatar
John Koleszar committed
197
198
199

#endif

Attila Nagy's avatar
Attila Nagy committed
200
201
202
                        // Count of last ref frame 0,0 useage
                        if ((xd->mode_info_context->mbmi.mode == ZEROMV) && (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME))
                            cpi->inter_zz_count++;
John Koleszar's avatar
John Koleszar committed
203

Attila Nagy's avatar
Attila Nagy committed
204
205
206
207
208
209
                        // Special case code for cyclic refresh
                        // If cyclic update enabled then copy xd->mbmi.segment_id; (which may have been updated based on mode
                        // during vp8cx_encode_inter_macroblock()) back into the global sgmentation map
                        if (cpi->cyclic_refresh_mode_enabled && xd->segmentation_enabled)
                        {
                            const MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
210
                            cpi->segmentation_map[map_index + mb_col] = mbmi->segment_id;
Attila Nagy's avatar
Attila Nagy committed
211
212
213
214
215

                            // If the block has been refreshed mark it as clean (the magnitude of the -ve influences how long it will be before we consider another refresh):
                            // Else if it was coded (last frame 0,0) and has not already been refreshed then mark it as a candidate for cleanup next time (marked 0)
                            // else mark it as dirty (1).
                            if (mbmi->segment_id)
216
                                cpi->cyclic_refresh_map[map_index + mb_col] = -1;
Attila Nagy's avatar
Attila Nagy committed
217
                            else if ((mbmi->mode == ZEROMV) && (mbmi->ref_frame == LAST_FRAME))
218
                            {
219
220
                                if (cpi->cyclic_refresh_map[map_index + mb_col] == 1)
                                    cpi->cyclic_refresh_map[map_index + mb_col] = 0;
221
                            }
Attila Nagy's avatar
Attila Nagy committed
222
                            else
223
                                cpi->cyclic_refresh_map[map_index + mb_col] = 1;
John Koleszar's avatar
John Koleszar committed
224

Attila Nagy's avatar
Attila Nagy committed
225
226
227
                        }
                    }
                    cpi->tplist[mb_row].stop = tp;
John Koleszar's avatar
John Koleszar committed
228

229
230
231
232
233
                    // Increment pointer into gf useage flags structure.
                    x->gf_active_ptr++;

                    // Increment the activity mask pointers.
                    x->mb_activity_ptr++;
John Koleszar's avatar
John Koleszar committed
234

Attila Nagy's avatar
Attila Nagy committed
235
236
237
238
                    // adjust to the next column of macroblocks
                    x->src.y_buffer += 16;
                    x->src.u_buffer += 8;
                    x->src.v_buffer += 8;
John Koleszar's avatar
John Koleszar committed
239

Attila Nagy's avatar
Attila Nagy committed
240
241
                    recon_yoffset += 16;
                    recon_uvoffset += 8;
John Koleszar's avatar
John Koleszar committed
242

Attila Nagy's avatar
Attila Nagy committed
243
244
                    // Keep track of segment useage
                    segment_counts[xd->mode_info_context->mbmi.segment_id]++;
John Koleszar's avatar
John Koleszar committed
245

Attila Nagy's avatar
Attila Nagy committed
246
                    // skip to next mb
John Koleszar's avatar
John Koleszar committed
247
                    xd->mode_info_context++;
248
                    x->partition_info++;
Attila Nagy's avatar
Attila Nagy committed
249
                    xd->above_context++;
John Koleszar's avatar
John Koleszar committed
250

Attila Nagy's avatar
Attila Nagy committed
251
252
                    cpi->mt_current_mb_col[mb_row] = mb_col;
                }
John Koleszar's avatar
John Koleszar committed
253

Attila Nagy's avatar
Attila Nagy committed
254
255
256
257
258
259
                //extend the recon for intra prediction
                vp8_extend_mb_row(
                    &cm->yv12_fb[dst_fb_idx],
                    xd->dst.y_buffer + 16,
                    xd->dst.u_buffer + 8,
                    xd->dst.v_buffer + 8);
John Koleszar's avatar
John Koleszar committed
260

Attila Nagy's avatar
Attila Nagy committed
261
262
263
                // this is to account for the border
                xd->mode_info_context++;
                x->partition_info++;
John Koleszar's avatar
John Koleszar committed
264

Attila Nagy's avatar
Attila Nagy committed
265
266
267
                x->src.y_buffer += 16 * x->src.y_stride * (cpi->encoding_thread_count + 1) - 16 * cm->mb_cols;
                x->src.u_buffer += 8 * x->src.uv_stride * (cpi->encoding_thread_count + 1) - 8 * cm->mb_cols;
                x->src.v_buffer += 8 * x->src.uv_stride * (cpi->encoding_thread_count + 1) - 8 * cm->mb_cols;
John Koleszar's avatar
John Koleszar committed
268

Attila Nagy's avatar
Attila Nagy committed
269
270
                xd->mode_info_context += xd->mode_info_stride * cpi->encoding_thread_count;
                x->partition_info += xd->mode_info_stride * cpi->encoding_thread_count;
271
                x->gf_active_ptr   += cm->mb_cols * cpi->encoding_thread_count;
Attila Nagy's avatar
Attila Nagy committed
272
273
274
275
276
277

                if (mb_row == cm->mb_rows - 1)
                {
                    //SetEvent(cpi->h_event_main);
                    sem_post(&cpi->h_event_end_encoding); /* signal frame encoding end */
                }
John Koleszar's avatar
John Koleszar committed
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
            }
        }
    }

    //printf("exit thread %d\n", ithread);
    return 0;
}

static void setup_mbby_copy(MACROBLOCK *mbdst, MACROBLOCK *mbsrc)
{

    MACROBLOCK *x = mbsrc;
    MACROBLOCK *z = mbdst;
    int i;

    z->ss               = x->ss;
    z->ss_count          = x->ss_count;
    z->searches_per_step  = x->searches_per_step;
    z->errorperbit      = x->errorperbit;

    z->sadperbit16      = x->sadperbit16;
    z->sadperbit4       = x->sadperbit4;

    /*
    z->mv_col_min    = x->mv_col_min;
    z->mv_col_max    = x->mv_col_max;
    z->mv_row_min    = x->mv_row_min;
    z->mv_row_max    = x->mv_row_max;
    z->vector_range = x->vector_range ;
    */

    z->vp8_short_fdct4x4     = x->vp8_short_fdct4x4;
    z->vp8_short_fdct8x4     = x->vp8_short_fdct8x4;
    z->short_walsh4x4    = x->short_walsh4x4;
    z->quantize_b        = x->quantize_b;
313
    z->quantize_b_pair   = x->quantize_b_pair;
314
    z->optimize          = x->optimize;
John Koleszar's avatar
John Koleszar committed
315
316
317
318
319
320
321
322
323
324
325
326

    /*
    z->mvc              = x->mvc;
    z->src.y_buffer      = x->src.y_buffer;
    z->src.u_buffer      = x->src.u_buffer;
    z->src.v_buffer      = x->src.v_buffer;
    */


    vpx_memcpy(z->mvcosts,          x->mvcosts,         sizeof(x->mvcosts));
    z->mvcost[0] = &z->mvcosts[0][mv_max+1];
    z->mvcost[1] = &z->mvcosts[1][mv_max+1];
327
328
    z->mvsadcost[0] = &z->mvsadcosts[0][mvfp_max+1];
    z->mvsadcost[1] = &z->mvsadcosts[1][mvfp_max+1];
John Koleszar's avatar
John Koleszar committed
329
330
331
332
333
334
335
336
337
338
339
340
341


    vpx_memcpy(z->token_costs,       x->token_costs,      sizeof(x->token_costs));
    vpx_memcpy(z->inter_bmode_costs,  x->inter_bmode_costs, sizeof(x->inter_bmode_costs));
    //memcpy(z->mvcosts,            x->mvcosts,         sizeof(x->mvcosts));
    //memcpy(z->mvcost,         x->mvcost,          sizeof(x->mvcost));
    vpx_memcpy(z->mbmode_cost,       x->mbmode_cost,      sizeof(x->mbmode_cost));
    vpx_memcpy(z->intra_uv_mode_cost,  x->intra_uv_mode_cost, sizeof(x->intra_uv_mode_cost));
    vpx_memcpy(z->bmode_costs,       x->bmode_costs,      sizeof(x->bmode_costs));

    for (i = 0; i < 25; i++)
    {
        z->block[i].quant           = x->block[i].quant;
342
        z->block[i].quant_fast      = x->block[i].quant_fast;
343
        z->block[i].quant_shift     = x->block[i].quant_shift;
John Koleszar's avatar
John Koleszar committed
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
        z->block[i].zbin            = x->block[i].zbin;
        z->block[i].zrun_zbin_boost   = x->block[i].zrun_zbin_boost;
        z->block[i].round           = x->block[i].round;
        /*
        z->block[i].src             = x->block[i].src;
        */
        z->block[i].src_stride       = x->block[i].src_stride;
        z->block[i].force_empty      = x->block[i].force_empty;

    }

    {
        MACROBLOCKD *xd = &x->e_mbd;
        MACROBLOCKD *zd = &z->e_mbd;

        /*
        zd->mode_info_context = xd->mode_info_context;
        zd->mode_info        = xd->mode_info;

        zd->mode_info_stride  = xd->mode_info_stride;
        zd->frame_type       = xd->frame_type;
        zd->up_available     = xd->up_available   ;
        zd->left_available   = xd->left_available;
        zd->left_context     = xd->left_context;
        zd->last_frame_dc     = xd->last_frame_dc;
        zd->last_frame_dccons = xd->last_frame_dccons;
        zd->gold_frame_dc     = xd->gold_frame_dc;
        zd->gold_frame_dccons = xd->gold_frame_dccons;
        zd->mb_to_left_edge    = xd->mb_to_left_edge;
        zd->mb_to_right_edge   = xd->mb_to_right_edge;
        zd->mb_to_top_edge     = xd->mb_to_top_edge   ;
        zd->mb_to_bottom_edge  = xd->mb_to_bottom_edge;
        zd->gf_active_ptr     = xd->gf_active_ptr;
        zd->frames_since_golden       = xd->frames_since_golden;
        zd->frames_till_alt_ref_frame   = xd->frames_till_alt_ref_frame;
        */
        zd->subpixel_predict         = xd->subpixel_predict;
        zd->subpixel_predict8x4      = xd->subpixel_predict8x4;
        zd->subpixel_predict8x8      = xd->subpixel_predict8x8;
        zd->subpixel_predict16x16    = xd->subpixel_predict16x16;
        zd->segmentation_enabled     = xd->segmentation_enabled;
        zd->mb_segement_abs_delta      = xd->mb_segement_abs_delta;
        vpx_memcpy(zd->segment_feature_data, xd->segment_feature_data, sizeof(xd->segment_feature_data));

        for (i = 0; i < 25; i++)
        {
            zd->block[i].dequant = xd->block[i].dequant;
        }
    }
}

void vp8cx_init_mbrthread_data(VP8_COMP *cpi,
                               MACROBLOCK *x,
                               MB_ROW_COMP *mbr_ei,
                               int mb_row,
                               int count
                              )
{

    VP8_COMMON *const cm = & cpi->common;
    MACROBLOCKD *const xd = & x->e_mbd;
    int i;
    (void) mb_row;

    for (i = 0; i < count; i++)
    {
        MACROBLOCK *mb = & mbr_ei[i].mb;
        MACROBLOCKD *mbd = &mb->e_mbd;

        mbd->subpixel_predict        = xd->subpixel_predict;
        mbd->subpixel_predict8x4     = xd->subpixel_predict8x4;
        mbd->subpixel_predict8x8     = xd->subpixel_predict8x8;
        mbd->subpixel_predict16x16   = xd->subpixel_predict16x16;
#if CONFIG_RUNTIME_CPU_DETECT
        mbd->rtcd                   = xd->rtcd;
#endif
420
        mb->gf_active_ptr            = x->gf_active_ptr;
John Koleszar's avatar
John Koleszar committed
421
422
423
424
425
426

        mb->vector_range             = 32;

        vpx_memset(mbr_ei[i].segment_counts, 0, sizeof(mbr_ei[i].segment_counts));
        mbr_ei[i].totalrate = 0;

427
428
        mb->partition_info = x->pi + x->e_mbd.mode_info_stride * (i + 1);

John Koleszar's avatar
John Koleszar committed
429
430
431
432
433
434
435
436
437
        mbd->mode_info_context = cm->mi   + x->e_mbd.mode_info_stride * (i + 1);
        mbd->mode_info_stride  = cm->mode_info_stride;

        mbd->frame_type = cm->frame_type;

        mbd->frames_since_golden = cm->frames_since_golden;
        mbd->frames_till_alt_ref_frame = cm->frames_till_alt_ref_frame;

        mb->src = * cpi->Source;
438
439
        mbd->pre = cm->yv12_fb[cm->lst_fb_idx];
        mbd->dst = cm->yv12_fb[cm->new_fb_idx];
John Koleszar's avatar
John Koleszar committed
440
441
442
443
444
445
446
447
448
449
450

        mb->src.y_buffer += 16 * x->src.y_stride * (i + 1);
        mb->src.u_buffer +=  8 * x->src.uv_stride * (i + 1);
        mb->src.v_buffer +=  8 * x->src.uv_stride * (i + 1);

        vp8_build_block_offsets(mb);

        vp8_setup_block_dptrs(mbd);

        vp8_setup_block_ptrs(mb);

451
        mbd->left_context = &cm->left_context;
John Koleszar's avatar
John Koleszar committed
452
453
454
455
        mb->mvc = cm->fc.mvc;

        setup_mbby_copy(&mbr_ei[i].mb, x);

Scott LaVarnway's avatar
Scott LaVarnway committed
456
457
458
        mbd->fullpixel_mask = 0xffffffff;
        if(cm->full_pixel)
            mbd->fullpixel_mask = 0xfffffff8;
John Koleszar's avatar
John Koleszar committed
459
460
461
462
463
    }
}

void vp8cx_create_encoder_threads(VP8_COMP *cpi)
{
464
    const VP8_COMMON * cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
465

466
467
    cpi->b_multi_threaded = 0;
    cpi->encoding_thread_count = 0;
John Koleszar's avatar
John Koleszar committed
468

469
    if (cm->processor_core_count > 1 && cpi->oxcf.multi_threaded > 1)
John Koleszar's avatar
John Koleszar committed
470
471
    {
        int ithread;
472
        int th_count = cpi->oxcf.multi_threaded - 1;
John Koleszar's avatar
John Koleszar committed
473

474
475
476
        /* don't allocate more threads than cores available */
        if (cpi->oxcf.multi_threaded > cm->processor_core_count)
            th_count = cm->processor_core_count - 1;
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496

        /* we have th_count + 1 (main) threads processing one row each */
        /* no point to have more threads than the sync range allows */
        if(th_count > ((cm->mb_cols / cpi->mt_sync_range) - 1))
        {
            th_count = (cm->mb_cols / cpi->mt_sync_range) - 1;
        }

        if(th_count == 0)
            return;

        CHECK_MEM_ERROR(cpi->h_encoding_thread, vpx_malloc(sizeof(pthread_t) * th_count));
        CHECK_MEM_ERROR(cpi->h_event_start_encoding, vpx_malloc(sizeof(sem_t) * th_count));
        CHECK_MEM_ERROR(cpi->mb_row_ei, vpx_memalign(32, sizeof(MB_ROW_COMP) * th_count));
        vpx_memset(cpi->mb_row_ei, 0, sizeof(MB_ROW_COMP) * th_count);
        CHECK_MEM_ERROR(cpi->en_thread_data,
                        vpx_malloc(sizeof(ENCODETHREAD_DATA) * th_count));
        CHECK_MEM_ERROR(cpi->mt_current_mb_col,
                        vpx_malloc(sizeof(*cpi->mt_current_mb_col) * cm->mb_rows));

Attila Nagy's avatar
Attila Nagy committed
497
        sem_init(&cpi->h_event_end_encoding, 0, 0);
John Koleszar's avatar
John Koleszar committed
498
499

        cpi->b_multi_threaded = 1;
500
        cpi->encoding_thread_count = th_count;
John Koleszar's avatar
John Koleszar committed
501

502
503
504
505
        /*
        printf("[VP8:] multi_threaded encoding is enabled with %d threads\n\n",
               (cpi->encoding_thread_count +1));
        */
John Koleszar's avatar
John Koleszar committed
506

507
        for (ithread = 0; ithread < th_count; ithread++)
John Koleszar's avatar
John Koleszar committed
508
        {
Attila Nagy's avatar
Attila Nagy committed
509
510
511
512
513
514
            ENCODETHREAD_DATA * ethd = &cpi->en_thread_data[ithread];

            sem_init(&cpi->h_event_start_encoding[ithread], 0, 0);
            ethd->ithread = ithread;
            ethd->ptr1 = (void *)cpi;
            ethd->ptr2 = (void *)&cpi->mb_row_ei[ithread];
John Koleszar's avatar
John Koleszar committed
515

Attila Nagy's avatar
Attila Nagy committed
516
            pthread_create(&cpi->h_encoding_thread[ithread], 0, thread_encoding_proc, ethd);
John Koleszar's avatar
John Koleszar committed
517
518
        }

519
520
521
522
523
524
525
526
527
        {
            LPFTHREAD_DATA * lpfthd = &cpi->lpf_thread_data;

            sem_init(&cpi->h_event_start_lpf, 0, 0);
            sem_init(&cpi->h_event_end_lpf, 0, 0);

            lpfthd->ptr1 = (void *)cpi;
            pthread_create(&cpi->h_filter_thread, 0, loopfilter_thread, lpfthd);
        }
John Koleszar's avatar
John Koleszar committed
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
    }

}

void vp8cx_remove_encoder_threads(VP8_COMP *cpi)
{
    if (cpi->b_multi_threaded)
    {
        //shutdown other threads
        cpi->b_multi_threaded = 0;
        {
            int i;

            for (i = 0; i < cpi->encoding_thread_count; i++)
            {
                //SetEvent(cpi->h_event_mbrencoding[i]);
Attila Nagy's avatar
Attila Nagy committed
544
                sem_post(&cpi->h_event_start_encoding[i]);
John Koleszar's avatar
John Koleszar committed
545
546
                pthread_join(cpi->h_encoding_thread[i], 0);

Attila Nagy's avatar
Attila Nagy committed
547
548
                sem_destroy(&cpi->h_event_start_encoding[i]);
            }
549
550
551

            sem_post(&cpi->h_event_start_lpf);
            pthread_join(cpi->h_filter_thread, 0);
John Koleszar's avatar
John Koleszar committed
552
        }
Attila Nagy's avatar
Attila Nagy committed
553
554

        sem_destroy(&cpi->h_event_end_encoding);
555
556
        sem_destroy(&cpi->h_event_end_lpf);
        sem_destroy(&cpi->h_event_start_lpf);
Attila Nagy's avatar
Attila Nagy committed
557

John Koleszar's avatar
John Koleszar committed
558
        //free thread related resources
Attila Nagy's avatar
Attila Nagy committed
559
        vpx_free(cpi->h_event_start_encoding);
John Koleszar's avatar
John Koleszar committed
560
561
562
        vpx_free(cpi->h_encoding_thread);
        vpx_free(cpi->mb_row_ei);
        vpx_free(cpi->en_thread_data);
Attila Nagy's avatar
Attila Nagy committed
563
        vpx_free(cpi->mt_current_mb_col);
John Koleszar's avatar
John Koleszar committed
564
565
    }
}
566
#endif