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

comparison libavcodec/h264_ompss.c @ 7:c8259123d224

find changesets by author, revision, files, or words in the commit message
hide animating VP and entry point
author Nina Engelhardt <nengel@mailbox.tu-berlin.de>
date Wed, 15 May 2013 15:26:14 +0200
parents 55fb61482128
children 6c1433f5a562
comparison
equal deleted inserted replaced
4:b3c99b2b41db 5:51c170445ade
38 38
39 int32 parse_taskArgTypes[4] = {INOUT, INOUT, OUTPUT, NONCTLD}; 39 int32 parse_taskArgTypes[4] = {INOUT, INOUT, OUTPUT, NONCTLD};
40 int32 parse_taskArgSizes[4] = {sizeof(ParserContext), sizeof(NalContext), sizeof(SliceBufferEntry), sizeof(H264Context)}; 40 int32 parse_taskArgSizes[4] = {sizeof(ParserContext), sizeof(NalContext), sizeof(SliceBufferEntry), sizeof(H264Context)};
41 41
42 //#pragma omp task inout(*pc, *nc) output(*sbe) 42 //#pragma omp task inout(*pc, *nc) output(*sbe)
43 static void parse_task(void *_data, SlaveVP *animatingSlv){ 43 static void parse_task(void *_data){
44 parse_taskArgs* args = (parse_taskArgs*) _data; 44 parse_taskArgs* args = (parse_taskArgs*) _data;
45 ParserContext *pc = args->pc; 45 ParserContext *pc = args->pc;
46 NalContext *nc = args->nc; 46 NalContext *nc = args->nc;
47 SliceBufferEntry *sbe = args->sbe; 47 SliceBufferEntry *sbe = args->sbe;
48 H264Context *h = args->h; 48 H264Context *h = args->h;
56 av_read_frame_internal(pc, &sbe->gb); 56 av_read_frame_internal(pc, &sbe->gb);
57 s = &sbe->slice; 57 s = &sbe->slice;
58 58
59 decode_nal_units(nc, s, &sbe->gb); 59 decode_nal_units(nc, s, &sbe->gb);
60 60
61 VSs__end_task( animatingSlv ); 61 VSs__end_task();
62 } 62 }
63 63
64 VSsTaskType parse_taskType = { 64 VSsTaskType parse_taskType = {
65 .fn = &parse_task, 65 .fn = &parse_task,
66 .numCtldArgs = 3, 66 .numCtldArgs = 3,
78 78
79 int32 decode_slice_entropy_taskArgTypes[3] = {INOUT, INOUT, NONCTLD}; 79 int32 decode_slice_entropy_taskArgTypes[3] = {INOUT, INOUT, NONCTLD};
80 int32 decode_slice_entropy_taskArgSizes[3] = {sizeof(EntropyContext), sizeof(SliceBufferEntry), sizeof(H264Context)}; 80 int32 decode_slice_entropy_taskArgSizes[3] = {sizeof(EntropyContext), sizeof(SliceBufferEntry), sizeof(H264Context)};
81 81
82 //#pragma omp task inout(*ec) inout(*sbe) 82 //#pragma omp task inout(*ec) inout(*sbe)
83 static void decode_slice_entropy_task(void *_data, SlaveVP *animatingSlv){ 83 static void decode_slice_entropy_task(void *_data){
84 decode_slice_entropy_taskArgs* args = (decode_slice_entropy_taskArgs*) _data; 84 decode_slice_entropy_taskArgs* args = (decode_slice_entropy_taskArgs*) _data;
85 EntropyContext *ec = args->ec; 85 EntropyContext *ec = args->ec;
86 SliceBufferEntry *sbe = args->sbe; 86 SliceBufferEntry *sbe = args->sbe;
87 H264Context *h = args->h; 87 H264Context *h = args->h;
88 int i,j; 88 int i,j;
92 // GetBitContext *gb = s->gb; 92 // GetBitContext *gb = s->gb;
93 CABACContext *c = &ec->c; 93 CABACContext *c = &ec->c;
94 94
95 if( !s->pps.cabac ){ 95 if( !s->pps.cabac ){
96 av_log(AV_LOG_ERROR, "Only cabac encoded streams are supported\n"); 96 av_log(AV_LOG_ERROR, "Only cabac encoded streams are supported\n");
97 VSs__end_task( animatingSlv ); 97 VSs__end_task();
98 } 98 }
99 99
100 init_dequant_tables(s, ec); 100 init_dequant_tables(s, ec);
101 ec->curr_qscale = s->qscale; 101 ec->curr_qscale = s->qscale;
102 ec->last_qscale_diff = 0; 102 ec->last_qscale_diff = 0;
122 ret = ff_h264_decode_mb_cabac(ec, s, c); 122 ret = ff_h264_decode_mb_cabac(ec, s, c);
123 eos = get_cabac_terminate( c); 123 eos = get_cabac_terminate( c);
124 (void) eos; 124 (void) eos;
125 if( ret < 0 || c->bytestream > c->bytestream_end + 2) { 125 if( ret < 0 || c->bytestream > c->bytestream_end + 2) {
126 av_log(AV_LOG_ERROR, "error while decoding MB %d %d, bytestream (%td)\n", m->mb_x, m->mb_y, c->bytestream_end - c->bytestream); 126 av_log(AV_LOG_ERROR, "error while decoding MB %d %d, bytestream (%td)\n", m->mb_x, m->mb_y, c->bytestream_end - c->bytestream);
127 VSs__end_task( animatingSlv ); 127 VSs__end_task();
128 } 128 }
129 } 129 }
130 } 130 }
131 VSs__end_task( animatingSlv ); 131 VSs__end_task();
132 } 132 }
133 133
134 VSsTaskType decode_slice_entropy_taskType = { 134 VSsTaskType decode_slice_entropy_taskType = {
135 .fn = &decode_slice_entropy_task, 135 .fn = &decode_slice_entropy_task,
136 .numCtldArgs = 2, 136 .numCtldArgs = 2,
165 165
166 int32 decode_super_mb_taskArgTypes[6] = {IN, IN, IN, IN, INOUT, NONCTLD}; 166 int32 decode_super_mb_taskArgTypes[6] = {IN, IN, IN, IN, INOUT, NONCTLD};
167 int32 decode_super_mb_taskArgSizes[6] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBContext)}; 167 int32 decode_super_mb_taskArgSizes[6] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBContext)};
168 168
169 //#pragma omp task input(*d, *sbe, *ml, *mur) inout(*m) 169 //#pragma omp task input(*d, *sbe, *ml, *mur) inout(*m)
170 static void decode_super_mb_task(void *_data, SlaveVP *animatingSlv){ 170 static void decode_super_mb_task(void *_data){
171 decode_super_mb_taskArgs* args = (decode_super_mb_taskArgs*) _data; 171 decode_super_mb_taskArgs* args = (decode_super_mb_taskArgs*) _data;
172 MBRecContext *d = args->d; 172 MBRecContext *d = args->d;
173 SliceBufferEntry *sbe = args->sbe; 173 SliceBufferEntry *sbe = args->sbe;
174 SuperMBTask *ml = args->ml; 174 SuperMBTask *ml = args->ml;
175 SuperMBTask *mur = args->mur; 175 SuperMBTask *mur = args->mur;
176 SuperMBTask *m = args->m; 176 SuperMBTask *m = args->m;
177 SuperMBContext *smbc = args->smbc; 177 SuperMBContext *smbc = args->smbc;
178 H264Slice *s = &sbe->slice; 178 H264Slice *s = &sbe->slice;
179 H264Mb *mbs = sbe->mbs; 179 H264Mb *mbs = sbe->mbs;
180 decode_super_mb_block(d, s, smbc, mbs, m->smb_x, m->smb_y); 180 decode_super_mb_block(d, s, smbc, mbs, m->smb_x, m->smb_y);
181 VSs__end_task( animatingSlv ); 181 VSs__end_task();
182 } 182 }
183 183
184 VSsTaskType decode_super_mb_taskType = { 184 VSsTaskType decode_super_mb_taskType = {
185 .fn = &decode_super_mb_task, 185 .fn = &decode_super_mb_task,
186 .numCtldArgs = 5, 186 .numCtldArgs = 5,
201 201
202 int32 draw_edges_taskArgTypes[5] = {IN, IN, INOUT, NONCTLD, NONCTLD}; 202 int32 draw_edges_taskArgTypes[5] = {IN, IN, INOUT, NONCTLD, NONCTLD};
203 int32 draw_edges_taskArgSizes[5] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask),sizeof(SuperMBContext),sizeof(int)}; 203 int32 draw_edges_taskArgSizes[5] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask),sizeof(SuperMBContext),sizeof(int)};
204 204
205 //#pragma omp task input(*d, *sbe) inout(*sm) 205 //#pragma omp task input(*d, *sbe) inout(*sm)
206 static void draw_edges_task(void *_data, SlaveVP *animatingSlv){ 206 static void draw_edges_task(void *_data){
207 draw_edges_taskArgs* args = (draw_edges_taskArgs*) _data; 207 draw_edges_taskArgs* args = (draw_edges_taskArgs*) _data;
208 MBRecContext *d = args->d; 208 MBRecContext *d = args->d;
209 SliceBufferEntry *sbe = args->sbe; 209 SliceBufferEntry *sbe = args->sbe;
210 SuperMBTask *sm = args->sm; 210 SuperMBTask *sm = args->sm;
211 SuperMBContext *smbc = args->smbc; 211 SuperMBContext *smbc = args->smbc;
212 int line = *(args->line); 212 int line = *(args->line);
213 H264Slice *s = &sbe->slice; 213 H264Slice *s = &sbe->slice;
214 for (int i=line*smbc->smb_height; i< (line+1)*smbc->smb_height && i< d->mb_height; i++) 214 for (int i=line*smbc->smb_height; i< (line+1)*smbc->smb_height && i< d->mb_height; i++)
215 draw_edges(d, s, i); 215 draw_edges(d, s, i);
216 VMS_App__free(args->line); 216 VMS_App__free(args->line);
217 VSs__end_task( animatingSlv ); 217 VSs__end_task();
218 } 218 }
219 VSsTaskType draw_edges_taskType = { 219 VSsTaskType draw_edges_taskType = {
220 .fn = &draw_edges_task, 220 .fn = &draw_edges_task,
221 .numCtldArgs = 3, 221 .numCtldArgs = 3,
222 .numTotalArgs = 5, 222 .numTotalArgs = 5,
223 .sizeOfArgs = sizeof(draw_edges_taskArgs), 223 .sizeOfArgs = sizeof(draw_edges_taskArgs),
224 .argTypes = draw_edges_taskArgTypes, 224 .argTypes = draw_edges_taskArgTypes,
225 .argSizes = draw_edges_taskArgSizes}; 225 .argSizes = draw_edges_taskArgSizes};
226 226
227 227
228 static void decode_mb_in_slice(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe, SlaveVP* animSlv){ 228 static void decode_mb_in_slice(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe){
229 int i,j; 229 int i,j;
230 230
231 SuperMBContext *smbc = acquire_smbc(h); 231 SuperMBContext *smbc = acquire_smbc(h);
232 int smb_height =smbc->nsmb_height, smb_width= smbc->nsmb_width; 232 int smb_height =smbc->nsmb_height, smb_width= smbc->nsmb_width;
233 SuperMBTask *smbs = smbc->smbs[0]; 233 SuperMBTask *smbs = smbc->smbs[0];
243 decode_super_mb_task_args.sbe = sbe; 243 decode_super_mb_task_args.sbe = sbe;
244 decode_super_mb_task_args.smbc = smbc; 244 decode_super_mb_task_args.smbc = smbc;
245 decode_super_mb_task_args.ml = sml; 245 decode_super_mb_task_args.ml = sml;
246 decode_super_mb_task_args.mur = smur; 246 decode_super_mb_task_args.mur = smur;
247 decode_super_mb_task_args.m = sm; 247 decode_super_mb_task_args.m = sm;
248 VSs__submit_task(&decode_super_mb_taskType, &decode_super_mb_task_args, animSlv); 248 VSs__submit_task(&decode_super_mb_taskType, &decode_super_mb_task_args);
249 } 249 }
250 draw_edges_taskArgs draw_edges_task_args; 250 draw_edges_taskArgs draw_edges_task_args;
251 draw_edges_task_args.d = d; 251 draw_edges_task_args.d = d;
252 draw_edges_task_args.sbe = sbe; 252 draw_edges_task_args.sbe = sbe;
253 draw_edges_task_args.sm = sm; 253 draw_edges_task_args.sm = sm;
254 draw_edges_task_args.smbc = smbc; 254 draw_edges_task_args.smbc = smbc;
255 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) ); 255 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) );
256 *(draw_edges_task_args.line) = j; 256 *(draw_edges_task_args.line) = j;
257 VSs__submit_task(&draw_edges_taskType, &draw_edges_task_args, animSlv); 257 VSs__submit_task(&draw_edges_taskType, &draw_edges_task_args);
258 } 258 }
259 VSs__taskwait_on(animSlv,sm); 259 VSs__taskwait_on(sm);
260 //#pragma omp taskwait on(*sm) 260 //#pragma omp taskwait on(*sm)
261 261
262 release_smbc(h, smbc); 262 release_smbc(h, smbc);
263 } 263 }
264 264
270 270
271 int32 decode_slice_mb_taskArgTypes[3] = {INOUT, INOUT, NONCTLD}; 271 int32 decode_slice_mb_taskArgTypes[3] = {INOUT, INOUT, NONCTLD};
272 int32 decode_slice_mb_taskArgSizes[3] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(H264Context)}; 272 int32 decode_slice_mb_taskArgSizes[3] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(H264Context)};
273 273
274 //#pragma omp task inout(*d) inout(*sbe) 274 //#pragma omp task inout(*d) inout(*sbe)
275 static void decode_slice_mb_task(void *_data, SlaveVP *animatingSlv){ 275 static void decode_slice_mb_task(void *_data){
276 decode_slice_mb_taskArgs* args = (decode_slice_mb_taskArgs*) _data; 276 decode_slice_mb_taskArgs* args = (decode_slice_mb_taskArgs*) _data;
277 MBRecContext *d = args->d; 277 MBRecContext *d = args->d;
278 SliceBufferEntry *sbe = args->sbe; 278 SliceBufferEntry *sbe = args->sbe;
279 H264Context *h = args->h; 279 H264Context *h = args->h;
280 280
293 } 293 }
294 } 294 }
295 } 295 }
296 296
297 //#pragma omp critical (dpb) 297 //#pragma omp critical (dpb)
298 VSs__start_critical(animatingSlv,0); 298 VSs__start_critical(0);
299 get_dpb_entry(h, s); 299 get_dpb_entry(h, s);
300 VSs__end_critical(animatingSlv,0); 300 VSs__end_critical(0);
301 301
302 if (!h->no_mbd){ 302 if (!h->no_mbd){
303 decode_mb_in_slice (h, d, sbe, animatingSlv); 303 decode_mb_in_slice (h, d, sbe);
304 } 304 }
305 305
306 for (int i=0; i<s->release_cnt; i++){ 306 for (int i=0; i<s->release_cnt; i++){
307 for(int j=0; j<h->max_dpb_cnt; j++){ 307 for(int j=0; j<h->max_dpb_cnt; j++){
308 if(h->dpb[j].cpn== s->release_ref_cpn[i]){ 308 if(h->dpb[j].cpn== s->release_ref_cpn[i]){
309 //#pragma omp critical (dpb) 309 //#pragma omp critical (dpb)
310 VSs__start_critical(animatingSlv,0); 310 VSs__start_critical(0);
311 release_dpb_entry(h, &h->dpb[j], 2); 311 release_dpb_entry(h, &h->dpb[j], 2);
312 VSs__end_critical(animatingSlv,0); 312 VSs__end_critical(0);
313 break; 313 break;
314 } 314 }
315 } 315 }
316 } 316 }
317 s->release_cnt=0; 317 s->release_cnt=0;
318 VSs__end_task( animatingSlv ); 318 VSs__end_task();
319 } 319 }
320 320
321 VSsTaskType decode_slice_mb_taskType = { 321 VSsTaskType decode_slice_mb_taskType = {
322 .fn = &decode_slice_mb_task, 322 .fn = &decode_slice_mb_task,
323 .numCtldArgs = 2, 323 .numCtldArgs = 2,
341 int32 decode_3dwave_super_mb_taskArgTypes[7] = {IN, IN, IN, IN, IN, INOUT, NONCTLD}; 341 int32 decode_3dwave_super_mb_taskArgTypes[7] = {IN, IN, IN, IN, IN, INOUT, NONCTLD};
342 int32 decode_3dwave_super_mb_taskArgSizes[7] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), 342 int32 decode_3dwave_super_mb_taskArgSizes[7] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask),
343 sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBContext)}; 343 sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBContext)};
344 344
345 //#pragma omp task input(*d, *sbe, *ml, *mur, *mprev) inout(*m) 345 //#pragma omp task input(*d, *sbe, *ml, *mur, *mprev) inout(*m)
346 static void decode_3dwave_super_mb_task(void *_data, SlaveVP *animatingSlv){ 346 static void decode_3dwave_super_mb_task(void *_data){
347 decode_3dwave_super_mb_taskArgs* args = (decode_3dwave_super_mb_taskArgs*) _data; 347 decode_3dwave_super_mb_taskArgs* args = (decode_3dwave_super_mb_taskArgs*) _data;
348 MBRecContext *d = args->d; 348 MBRecContext *d = args->d;
349 SliceBufferEntry *sbe = args->sbe; 349 SliceBufferEntry *sbe = args->sbe;
350 SuperMBTask *ml = args->ml; 350 SuperMBTask *ml = args->ml;
351 SuperMBTask *mur = args->mur; 351 SuperMBTask *mur = args->mur;
355 355
356 H264Slice *s = &sbe->slice; 356 H264Slice *s = &sbe->slice;
357 H264Mb *mbs = sbe->mbs; 357 H264Mb *mbs = sbe->mbs;
358 358
359 decode_super_mb_block(d, s, smbc, mbs, m->smb_x, m->smb_y); 359 decode_super_mb_block(d, s, smbc, mbs, m->smb_x, m->smb_y);
360 VSs__end_task( animatingSlv ); 360 VSs__end_task();
361 } 361 }
362 362
363 VSsTaskType decode_3dwave_super_mb_taskType = { 363 VSsTaskType decode_3dwave_super_mb_taskType = {
364 .fn = &decode_3dwave_super_mb_task, 364 .fn = &decode_3dwave_super_mb_task,
365 .numCtldArgs = 6, 365 .numCtldArgs = 6,
378 378
379 int32 init_ref_list_and_get_dpb_taskArgTypes[4] = {INOUT, INOUT, INOUT, NONCTLD}; 379 int32 init_ref_list_and_get_dpb_taskArgTypes[4] = {INOUT, INOUT, INOUT, NONCTLD};
380 int32 init_ref_list_and_get_dpb_taskArgSizes[4] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(int), sizeof(H264Context)}; 380 int32 init_ref_list_and_get_dpb_taskArgSizes[4] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(int), sizeof(H264Context)};
381 381
382 //#pragma omp task inout(*d, *sbe, *init) 382 //#pragma omp task inout(*d, *sbe, *init)
383 static void init_ref_list_and_get_dpb_task(void *_data, SlaveVP *animatingSlv){ 383 static void init_ref_list_and_get_dpb_task(void *_data){
384 init_ref_list_and_get_dpb_taskArgs* args = (init_ref_list_and_get_dpb_taskArgs*) _data; 384 init_ref_list_and_get_dpb_taskArgs* args = (init_ref_list_and_get_dpb_taskArgs*) _data;
385 MBRecContext *d = args->d; 385 MBRecContext *d = args->d;
386 SliceBufferEntry *sbe = args->sbe; 386 SliceBufferEntry *sbe = args->sbe;
387 int* initp = args->init; 387 int* initp = args->init;
388 H264Context *h = args->h; 388 H264Context *h = args->h;
401 } 401 }
402 } 402 }
403 } 403 }
404 404
405 //#pragma omp critical (dpb) 405 //#pragma omp critical (dpb)
406 VSs__start_critical(animatingSlv,0); 406 VSs__start_critical(0);
407 get_dpb_entry(h, s); 407 get_dpb_entry(h, s);
408 VSs__end_critical(animatingSlv,0); 408 VSs__end_critical(0);
409 409
410 VSs__end_task( animatingSlv ); 410 VSs__end_task();
411 } 411 }
412 412
413 VSsTaskType init_ref_list_and_get_dpb_taskType = { 413 VSsTaskType init_ref_list_and_get_dpb_taskType = {
414 .fn = &init_ref_list_and_get_dpb_task, 414 .fn = &init_ref_list_and_get_dpb_task,
415 .numCtldArgs = 3, 415 .numCtldArgs = 3,
416 .numTotalArgs = 4, 416 .numTotalArgs = 4,
417 .sizeOfArgs = sizeof(init_ref_list_and_get_dpb_taskArgs), 417 .sizeOfArgs = sizeof(init_ref_list_and_get_dpb_taskArgs),
418 .argTypes = init_ref_list_and_get_dpb_taskArgTypes, 418 .argTypes = init_ref_list_and_get_dpb_taskArgTypes,
419 .argSizes = init_ref_list_and_get_dpb_taskArgSizes}; 419 .argSizes = init_ref_list_and_get_dpb_taskArgSizes};
420 420
421 static SuperMBTask* add_decode_slice_3dwave_tasks(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, int k, SlaveVP* animSlv){ 421 static SuperMBTask* add_decode_slice_3dwave_tasks(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, int k){
422 int i,j; 422 int i,j;
423 423
424 int32* taskID; 424 int32* taskID;
425 425
426 int smb_3d_height =smbc->nsmb_3dheight; 426 int smb_3d_height =smbc->nsmb_3dheight;
443 decode_3dwave_super_mb_task_args.smbc = smbc; 443 decode_3dwave_super_mb_task_args.smbc = smbc;
444 decode_3dwave_super_mb_task_args.ml = sml; 444 decode_3dwave_super_mb_task_args.ml = sml;
445 decode_3dwave_super_mb_task_args.mur = smur; 445 decode_3dwave_super_mb_task_args.mur = smur;
446 decode_3dwave_super_mb_task_args.mprev = smprev; 446 decode_3dwave_super_mb_task_args.mprev = smprev;
447 decode_3dwave_super_mb_task_args.m = sm; 447 decode_3dwave_super_mb_task_args.m = sm;
448 taskID = VSs__create_taskID_of_size(3,animSlv ); 448 taskID = VSs__create_taskID_of_size(3 );
449 taskID[1] = k; 449 taskID[1] = k;
450 taskID[2] = j; 450 taskID[2] = j;
451 taskID[3] = i; 451 taskID[3] = i;
452 VSs__submit_task_with_ID(&decode_3dwave_super_mb_taskType, &decode_3dwave_super_mb_task_args, taskID, animSlv); 452 VSs__submit_task_with_ID(&decode_3dwave_super_mb_taskType, &decode_3dwave_super_mb_task_args, taskID);
453 } 453 }
454 draw_edges_taskArgs draw_edges_task_args; 454 draw_edges_taskArgs draw_edges_task_args;
455 draw_edges_task_args.d = d; 455 draw_edges_task_args.d = d;
456 draw_edges_task_args.sbe = sbe; 456 draw_edges_task_args.sbe = sbe;
457 draw_edges_task_args.sm = sm; 457 draw_edges_task_args.sm = sm;
458 draw_edges_task_args.smbc = smbc; 458 draw_edges_task_args.smbc = smbc;
459 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) ); 459 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) );
460 *(draw_edges_task_args.line) = j; 460 *(draw_edges_task_args.line) = j;
461 taskID = VSs__create_taskID_of_size(3, animSlv); 461 taskID = VSs__create_taskID_of_size(3);
462 taskID[1] = k; 462 taskID[1] = k;
463 taskID[2] = j; 463 taskID[2] = j;
464 taskID[3] = i; 464 taskID[3] = i;
465 VSs__submit_task_with_ID(&draw_edges_taskType, &draw_edges_task_args, taskID, animSlv); 465 VSs__submit_task_with_ID(&draw_edges_taskType, &draw_edges_task_args, taskID);
466 } 466 }
467 467
468 for(; j< smb_height; j++){ 468 for(; j< smb_height; j++){
469 for(i=0; i< smb_width; i++){ 469 for(i=0; i< smb_width; i++){
470 sm = smbs + j*smb_width + i; 470 sm = smbs + j*smb_width + i;
475 decode_super_mb_task_args.sbe = sbe; 475 decode_super_mb_task_args.sbe = sbe;
476 decode_super_mb_task_args.smbc = smbc; 476 decode_super_mb_task_args.smbc = smbc;
477 decode_super_mb_task_args.ml = sml; 477 decode_super_mb_task_args.ml = sml;
478 decode_super_mb_task_args.mur = smur; 478 decode_super_mb_task_args.mur = smur;
479 decode_super_mb_task_args.m = sm; 479 decode_super_mb_task_args.m = sm;
480 taskID = VSs__create_taskID_of_size(3,animSlv ); 480 taskID = VSs__create_taskID_of_size(3 );
481 taskID[1] = k; 481 taskID[1] = k;
482 taskID[2] = j; 482 taskID[2] = j;
483 taskID[3] = i; 483 taskID[3] = i;
484 VSs__submit_task_with_ID(&decode_super_mb_taskType, &decode_super_mb_task_args, taskID, animSlv); 484 VSs__submit_task_with_ID(&decode_super_mb_taskType, &decode_super_mb_task_args, taskID);
485 } 485 }
486 draw_edges_taskArgs draw_edges_task_args; 486 draw_edges_taskArgs draw_edges_task_args;
487 draw_edges_task_args.d = d; 487 draw_edges_task_args.d = d;
488 draw_edges_task_args.sbe = sbe; 488 draw_edges_task_args.sbe = sbe;
489 draw_edges_task_args.sm = sm; 489 draw_edges_task_args.sm = sm;
490 draw_edges_task_args.smbc = smbc; 490 draw_edges_task_args.smbc = smbc;
491 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) ); 491 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) );
492 *(draw_edges_task_args.line) = j; 492 *(draw_edges_task_args.line) = j;
493 taskID = VSs__create_taskID_of_size(3, animSlv); 493 taskID = VSs__create_taskID_of_size(3);
494 taskID[1] = k; 494 taskID[1] = k;
495 taskID[2] = j; 495 taskID[2] = j;
496 taskID[3] = i; 496 taskID[3] = i;
497 VSs__submit_task_with_ID(&draw_edges_taskType, &draw_edges_task_args, taskID, animSlv); 497 VSs__submit_task_with_ID(&draw_edges_taskType, &draw_edges_task_args, taskID);
498 } 498 }
499 return sm; 499 return sm;
500 } 500 }
501 501
502 typedef struct{ 502 typedef struct{
510 510
511 int32 release_ref_list_taskArgTypes[6] = {INOUT, INOUT, IN, INOUT, NONCTLD, NONCTLD}; 511 int32 release_ref_list_taskArgTypes[6] = {INOUT, INOUT, IN, INOUT, NONCTLD, NONCTLD};
512 int32 release_ref_list_taskArgSizes[6] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(int), sizeof(H264Context), sizeof(SuperMBContext)}; 512 int32 release_ref_list_taskArgSizes[6] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(int), sizeof(H264Context), sizeof(SuperMBContext)};
513 513
514 //#pragma omp task inout(*d, *sbe, *release) input (*lastsmb) 514 //#pragma omp task inout(*d, *sbe, *release) input (*lastsmb)
515 static void release_ref_list_task(void *_data, SlaveVP *animatingSlv){ 515 static void release_ref_list_task(void *_data){
516 release_ref_list_taskArgs* args = (release_ref_list_taskArgs*) _data; 516 release_ref_list_taskArgs* args = (release_ref_list_taskArgs*) _data;
517 MBRecContext *d = args->d; 517 MBRecContext *d = args->d;
518 SliceBufferEntry *sbe = args->sbe; 518 SliceBufferEntry *sbe = args->sbe;
519 SuperMBTask *lastsmb = args->lastsmb; 519 SuperMBTask *lastsmb = args->lastsmb;
520 int* releasep = args->release; 520 int* releasep = args->release;
524 H264Slice *s = &sbe->slice; 524 H264Slice *s = &sbe->slice;
525 for (int i=0; i<s->release_cnt; i++){ 525 for (int i=0; i<s->release_cnt; i++){
526 for(int j=0; j<h->max_dpb_cnt; j++){ 526 for(int j=0; j<h->max_dpb_cnt; j++){
527 if(h->dpb[j].cpn== s->release_ref_cpn[i]){ 527 if(h->dpb[j].cpn== s->release_ref_cpn[i]){
528 //#pragma omp critical (dpb) 528 //#pragma omp critical (dpb)
529 VSs__start_critical(animatingSlv,0); 529 VSs__start_critical(0);
530 release_dpb_entry(h, &h->dpb[j], 2); 530 release_dpb_entry(h, &h->dpb[j], 2);
531 VSs__end_critical(animatingSlv,0); 531 VSs__end_critical(0);
532 break; 532 break;
533 } 533 }
534 } 534 }
535 } 535 }
536 s->release_cnt=0; 536 s->release_cnt=0;
537 537
538 release_smbc(h, smbc); 538 release_smbc(h, smbc);
539 539
540 VSs__end_task( animatingSlv ); 540 VSs__end_task();
541 } 541 }
542 542
543 VSsTaskType release_ref_list_taskType = { 543 VSsTaskType release_ref_list_taskType = {
544 .fn = &release_ref_list_task, 544 .fn = &release_ref_list_task,
545 .numCtldArgs = 4, 545 .numCtldArgs = 4,
562 562
563 int32 output_taskArgTypes[3] = {INOUT, IN, NONCTLD}; 563 int32 output_taskArgTypes[3] = {INOUT, IN, NONCTLD};
564 int32 output_taskArgSizes[3] = {sizeof(OutputContext), sizeof(SliceBufferEntry), sizeof(H264Context)}; 564 int32 output_taskArgSizes[3] = {sizeof(OutputContext), sizeof(SliceBufferEntry), sizeof(H264Context)};
565 565
566 //#pragma omp task inout (*oc) input(*sbe) 566 //#pragma omp task inout (*oc) input(*sbe)
567 static void output_task(void *_data, SlaveVP *animatingSlv){ 567 static void output_task(void *_data){
568 output_taskArgs* args = (output_taskArgs*) _data; 568 output_taskArgs* args = (output_taskArgs*) _data;
569 OutputContext *oc = args->oc; 569 OutputContext *oc = args->oc;
570 SliceBufferEntry *sbe = args->sbe; 570 SliceBufferEntry *sbe = args->sbe;
571 H264Context *h = args->h; 571 H264Context *h = args->h;
572 572
573 DecodedPicture* out =output_frame(h, oc, sbe->slice.curr_pic, h->ofile, h->frame_width, h->frame_height); 573 DecodedPicture* out =output_frame(h, oc, sbe->slice.curr_pic, h->ofile, h->frame_width, h->frame_height);
574 if (out){ 574 if (out){
575 //#pragma omp critical (dpb) 575 //#pragma omp critical (dpb)
576 VSs__start_critical(animatingSlv,0); 576 VSs__start_critical(0);
577 release_dpb_entry(h, out, 1); 577 release_dpb_entry(h, out, 1);
578 VSs__end_critical(animatingSlv,0); 578 VSs__end_critical(0);
579 } 579 }
580 //print_report(oc->frame_number, oc->video_size, 0, h->verbose); 580 //print_report(oc->frame_number, oc->video_size, 0, h->verbose);
581 581
582 VSs__end_task( animatingSlv ); 582 VSs__end_task();
583 } 583 }
584 584
585 VSsTaskType output_taskType = { 585 VSsTaskType output_taskType = {
586 .fn = &output_task, 586 .fn = &output_task,
587 .numCtldArgs = 2, 587 .numCtldArgs = 2,
591 .argSizes = output_taskArgSizes}; 591 .argSizes = output_taskArgSizes};
592 592
593 /* 593 /*
594 * The following code is the main loop of the file converter 594 * The following code is the main loop of the file converter
595 */ 595 */
596 //Put VMS entry point here 596
597 597 int h264_decode_ompss( H264Context *h) {
598 void h264_decode_ompss( void *_params, SlaveVP *animSlv) {
599 H264Context* h = (H264Context*) _params;
600 598
601 const int bufs = h->pipe_bufs; 599 const int bufs = h->pipe_bufs;
602 600
603 ParserContext *pc; 601 ParserContext *pc;
604 NalContext *nc; 602 NalContext *nc;
645 parse_taskArgs parse_task_args; 643 parse_taskArgs parse_task_args;
646 parse_task_args.h = h; 644 parse_task_args.h = h;
647 parse_task_args.pc = pc; 645 parse_task_args.pc = pc;
648 parse_task_args.nc = nc; 646 parse_task_args.nc = nc;
649 parse_task_args.sbe = &sbe[k%bufs]; 647 parse_task_args.sbe = &sbe[k%bufs];
650 taskID = VSs__create_taskID_of_size(2,animSlv ); 648 taskID = VSs__create_taskID_of_size(2);
651 taskID[1] = 1; 649 taskID[1] = 1;
652 taskID[2] = k; 650 taskID[2] = k;
653 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, taskID, animSlv); 651 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, taskID);
654 652
655 decode_slice_entropy_taskArgs decode_slice_entropy_task_args; 653 decode_slice_entropy_taskArgs decode_slice_entropy_task_args;
656 decode_slice_entropy_task_args.h = h; 654 decode_slice_entropy_task_args.h = h;
657 decode_slice_entropy_task_args.ec = ec[k%bufs]; 655 decode_slice_entropy_task_args.ec = ec[k%bufs];
658 decode_slice_entropy_task_args.sbe = &sbe[k%bufs]; 656 decode_slice_entropy_task_args.sbe = &sbe[k%bufs];
659 taskID = VSs__create_taskID_of_size(2,animSlv ); 657 taskID = VSs__create_taskID_of_size(2);
660 taskID[1] = 2; 658 taskID[1] = 2;
661 taskID[2] = k; 659 taskID[2] = k;
662 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, taskID, animSlv); 660 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, taskID);
663 //#pragma omp taskwait on(*pc) 661 //#pragma omp taskwait on(*pc)
664 VSs__taskwait_on(animSlv,pc); 662 VSs__taskwait_on(pc);
665 k++; 663 k++;
666 } 664 }
667 665
668 while(!pc->final_frame && frames++ < h->num_frames && !h->quit){ 666 while(!pc->final_frame && frames++ < h->num_frames && !h->quit){
669 parse_taskArgs parse_task_args; 667 parse_taskArgs parse_task_args;
670 parse_task_args.h = h; 668 parse_task_args.h = h;
671 parse_task_args.pc = pc; 669 parse_task_args.pc = pc;
672 parse_task_args.nc = nc; 670 parse_task_args.nc = nc;
673 parse_task_args.sbe = &sbe[k%bufs]; 671 parse_task_args.sbe = &sbe[k%bufs];
674 taskID = VSs__create_taskID_of_size(2,animSlv ); 672 taskID = VSs__create_taskID_of_size(2);
675 taskID[1] = 3; 673 taskID[1] = 3;
676 taskID[2] = k; 674 taskID[2] = k;
677 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, taskID, animSlv); 675 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, taskID);
678 676
679 decode_slice_entropy_taskArgs decode_slice_entropy_task_args; 677 decode_slice_entropy_taskArgs decode_slice_entropy_task_args;
680 decode_slice_entropy_task_args.h = h; 678 decode_slice_entropy_task_args.h = h;
681 decode_slice_entropy_task_args.ec = ec[k%bufs]; 679 decode_slice_entropy_task_args.ec = ec[k%bufs];
682 decode_slice_entropy_task_args.sbe = &sbe[k%bufs]; 680 decode_slice_entropy_task_args.sbe = &sbe[k%bufs];
683 taskID = VSs__create_taskID_of_size(2,animSlv ); 681 taskID = VSs__create_taskID_of_size(2);
684 taskID[1] = 4; 682 taskID[1] = 4;
685 taskID[2] = k; 683 taskID[2] = k;
686 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, taskID, animSlv); 684 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, taskID);
687 685
688 k++; 686 k++;
689 687
690 init_ref_list_and_get_dpb_taskArgs init_ref_list_and_get_dpb_task_args; 688 init_ref_list_and_get_dpb_taskArgs init_ref_list_and_get_dpb_task_args;
691 init_ref_list_and_get_dpb_task_args.h = h; 689 init_ref_list_and_get_dpb_task_args.h = h;
692 init_ref_list_and_get_dpb_task_args.d = rc[k%2]; 690 init_ref_list_and_get_dpb_task_args.d = rc[k%2];
693 init_ref_list_and_get_dpb_task_args.sbe = &sbe[k%bufs]; 691 init_ref_list_and_get_dpb_task_args.sbe = &sbe[k%bufs];
694 init_ref_list_and_get_dpb_task_args.init = &init; 692 init_ref_list_and_get_dpb_task_args.init = &init;
695 taskID = VSs__create_taskID_of_size(2,animSlv ); 693 taskID = VSs__create_taskID_of_size(2);
696 taskID[1] = 5; 694 taskID[1] = 5;
697 taskID[2] = k; 695 taskID[2] = k;
698 VSs__submit_task_with_ID(&init_ref_list_and_get_dpb_taskType, &init_ref_list_and_get_dpb_task_args, taskID, animSlv); 696 VSs__submit_task_with_ID(&init_ref_list_and_get_dpb_taskType, &init_ref_list_and_get_dpb_task_args, taskID);
699 697
700 smbc = acquire_smbc(h); 698 smbc = acquire_smbc(h);
701 SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc, k, animSlv); 699 SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc, k);
702 release_ref_list_taskArgs release_ref_list_task_args; 700 release_ref_list_taskArgs release_ref_list_task_args;
703 release_ref_list_task_args.h = h; 701 release_ref_list_task_args.h = h;
704 release_ref_list_task_args.smbc = smbc; 702 release_ref_list_task_args.smbc = smbc;
705 release_ref_list_task_args.d = rc[k%2]; 703 release_ref_list_task_args.d = rc[k%2];
706 release_ref_list_task_args.sbe = &sbe[k%bufs]; 704 release_ref_list_task_args.sbe = &sbe[k%bufs];
707 release_ref_list_task_args.lastsmb = lastsmb; 705 release_ref_list_task_args.lastsmb = lastsmb;
708 release_ref_list_task_args.release = &release; 706 release_ref_list_task_args.release = &release;
709 taskID = VSs__create_taskID_of_size(2,animSlv ); 707 taskID = VSs__create_taskID_of_size(2);
710 taskID[1] = 6; 708 taskID[1] = 6;
711 taskID[2] = k; 709 taskID[2] = k;
712 VSs__submit_task_with_ID(&release_ref_list_taskType, &release_ref_list_task_args, taskID, animSlv); 710 VSs__submit_task_with_ID(&release_ref_list_taskType, &release_ref_list_task_args, taskID);
713 711
714 output_taskArgs output_task_args; 712 output_taskArgs output_task_args;
715 output_task_args.h = h; 713 output_task_args.h = h;
716 output_task_args.oc = oc; 714 output_task_args.oc = oc;
717 output_task_args.sbe = &sbe[k%bufs]; 715 output_task_args.sbe = &sbe[k%bufs];
718 taskID = VSs__create_taskID_of_size(2,animSlv ); 716 taskID = VSs__create_taskID_of_size(2);
719 taskID[1] = 7; 717 taskID[1] = 7;
720 taskID[2] = k; 718 taskID[2] = k;
721 VSs__submit_task_with_ID(&output_taskType, &output_task_args, taskID, animSlv); 719 VSs__submit_task_with_ID(&output_taskType, &output_task_args, taskID);
722 //#pragma omp taskwait on(*pc) 720 //#pragma omp taskwait on(*pc)
723 VSs__taskwait_on(animSlv,pc); 721 VSs__taskwait_on(pc);
724 } 722 }
725 723
726 for (int i=0; i< num_pre_ed; i++){ 724 for (int i=0; i< num_pre_ed; i++){
727 k++; 725 k++;
728 init_ref_list_and_get_dpb_taskArgs init_ref_list_and_get_dpb_task_args; 726 init_ref_list_and_get_dpb_taskArgs init_ref_list_and_get_dpb_task_args;
729 init_ref_list_and_get_dpb_task_args.h = h; 727 init_ref_list_and_get_dpb_task_args.h = h;
730 init_ref_list_and_get_dpb_task_args.d = rc[k%2]; 728 init_ref_list_and_get_dpb_task_args.d = rc[k%2];
731 init_ref_list_and_get_dpb_task_args.sbe = &sbe[k%bufs]; 729 init_ref_list_and_get_dpb_task_args.sbe = &sbe[k%bufs];
732 init_ref_list_and_get_dpb_task_args.init = &init; 730 init_ref_list_and_get_dpb_task_args.init = &init;
733 taskID = VSs__create_taskID_of_size(2,animSlv ); 731 taskID = VSs__create_taskID_of_size(2);
734 taskID[1] = 8; 732 taskID[1] = 8;
735 taskID[2] = i; 733 taskID[2] = i;
736 VSs__submit_task_with_ID(&init_ref_list_and_get_dpb_taskType, &init_ref_list_and_get_dpb_task_args, taskID, animSlv); 734 VSs__submit_task_with_ID(&init_ref_list_and_get_dpb_taskType, &init_ref_list_and_get_dpb_task_args, taskID);
737 smbc = acquire_smbc(h); 735 smbc = acquire_smbc(h);
738 SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc, k, animSlv); 736 SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc, k);
739 release_ref_list_taskArgs release_ref_list_task_args; 737 release_ref_list_taskArgs release_ref_list_task_args;
740 release_ref_list_task_args.h = h; 738 release_ref_list_task_args.h = h;
741 release_ref_list_task_args.smbc = smbc; 739 release_ref_list_task_args.smbc = smbc;
742 release_ref_list_task_args.d = rc[k%2]; 740 release_ref_list_task_args.d = rc[k%2];
743 release_ref_list_task_args.sbe = &sbe[k%bufs]; 741 release_ref_list_task_args.sbe = &sbe[k%bufs];
744 release_ref_list_task_args.lastsmb = lastsmb; 742 release_ref_list_task_args.lastsmb = lastsmb;
745 release_ref_list_task_args.release = &release; 743 release_ref_list_task_args.release = &release;
746 taskID = VSs__create_taskID_of_size(2,animSlv ); 744 taskID = VSs__create_taskID_of_size(2);
747 taskID[1] = 9; 745 taskID[1] = 9;
748 taskID[2] = k; 746 taskID[2] = k;
749 VSs__submit_task_with_ID(&release_ref_list_taskType, &release_ref_list_task_args, taskID, animSlv); 747 VSs__submit_task_with_ID(&release_ref_list_taskType, &release_ref_list_task_args, taskID);
750 748
751 output_taskArgs output_task_args; 749 output_taskArgs output_task_args;
752 output_task_args.h = h; 750 output_task_args.h = h;
753 output_task_args.oc = oc; 751 output_task_args.oc = oc;
754 output_task_args.sbe = &sbe[k%bufs]; 752 output_task_args.sbe = &sbe[k%bufs];
755 taskID = VSs__create_taskID_of_size(2,animSlv ); 753 taskID = VSs__create_taskID_of_size(2);
756 taskID[1] = 10; 754 taskID[1] = 10;
757 taskID[2] = k; 755 taskID[2] = k;
758 VSs__submit_task_with_ID(&output_taskType, &output_task_args, taskID, animSlv); 756 VSs__submit_task_with_ID(&output_taskType, &output_task_args, taskID);
759 } 757 }
760 758
761 } else { 759 } else {
762 while(!pc->final_frame && frames++ < h->num_frames && !h->quit){ 760 while(!pc->final_frame && frames++ < h->num_frames && !h->quit){
763 761
764 taskID = VSs__create_taskID_of_size(1,animSlv ); 762 taskID = VSs__create_taskID_of_size(1);
765 taskID[1] = frames*10+1; 763 taskID[1] = frames*10+1;
766 parse_taskArgs parse_task_args; 764 parse_taskArgs parse_task_args;
767 parse_task_args.h = h; 765 parse_task_args.h = h;
768 parse_task_args.pc = pc; 766 parse_task_args.pc = pc;
769 parse_task_args.nc = nc; 767 parse_task_args.nc = nc;
770 parse_task_args.sbe = &sbe[k%bufs]; 768 parse_task_args.sbe = &sbe[k%bufs];
771 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, taskID, animSlv); 769 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, taskID);
772 770
773 taskID = VSs__create_taskID_of_size(1,animSlv ); 771 taskID = VSs__create_taskID_of_size(1);
774 taskID[1] = frames*10+2; 772 taskID[1] = frames*10+2;
775 decode_slice_entropy_taskArgs decode_slice_entropy_task_args; 773 decode_slice_entropy_taskArgs decode_slice_entropy_task_args;
776 decode_slice_entropy_task_args.h = h; 774 decode_slice_entropy_task_args.h = h;
777 decode_slice_entropy_task_args.ec = ec[k%bufs]; 775 decode_slice_entropy_task_args.ec = ec[k%bufs];
778 decode_slice_entropy_task_args.sbe = &sbe[k%bufs]; 776 decode_slice_entropy_task_args.sbe = &sbe[k%bufs];
779 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args,taskID, animSlv); 777 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args,taskID);
780 778
781 taskID = VSs__create_taskID_of_size(1,animSlv ); 779 taskID = VSs__create_taskID_of_size(1);
782 taskID[1] = frames*10+3; 780 taskID[1] = frames*10+3;
783 decode_slice_mb_taskArgs decode_slice_mb_task_args; 781 decode_slice_mb_taskArgs decode_slice_mb_task_args;
784 decode_slice_mb_task_args.h = h; 782 decode_slice_mb_task_args.h = h;
785 decode_slice_mb_task_args.d = rc[0]; 783 decode_slice_mb_task_args.d = rc[0];
786 decode_slice_mb_task_args.sbe = &sbe[k%bufs]; 784 decode_slice_mb_task_args.sbe = &sbe[k%bufs];
787 VSs__submit_task_with_ID(&decode_slice_mb_taskType, &decode_slice_mb_task_args,taskID, animSlv); 785 VSs__submit_task_with_ID(&decode_slice_mb_taskType, &decode_slice_mb_task_args,taskID);
788 786
789 taskID = VSs__create_taskID_of_size(1,animSlv ); 787 taskID = VSs__create_taskID_of_size(1);
790 taskID[1] = frames*10+4; 788 taskID[1] = frames*10+4;
791 output_taskArgs output_task_args; 789 output_taskArgs output_task_args;
792 output_task_args.h = h; 790 output_task_args.h = h;
793 output_task_args.oc = oc; 791 output_task_args.oc = oc;
794 output_task_args.sbe = &sbe[k%bufs]; 792 output_task_args.sbe = &sbe[k%bufs];
795 VSs__submit_task_with_ID(&output_taskType, &output_task_args,taskID, animSlv); 793 VSs__submit_task_with_ID(&output_taskType, &output_task_args,taskID);
796 //#pragma omp taskwait on(*pc) 794 //#pragma omp taskwait on(*pc)
797 VSs__taskwait_on(animSlv,pc); 795 VSs__taskwait_on(pc);
798 k++; 796 k++;
799 } 797 }
800 } 798 }
801 //#pragma omp taskwait 799 //#pragma omp taskwait
802 VSs__taskwait(animSlv); 800 VSs__taskwait();
803 801
804 while ((out=output_frame(h, oc, NULL, h->ofile, h->frame_width, h->frame_height))) ; 802 while ((out=output_frame(h, oc, NULL, h->ofile, h->frame_width, h->frame_height))) ;
805 803
806 //print_report(oc->frame_number, oc->video_size, 1, h->verbose); 804 //print_report(oc->frame_number, oc->video_size, 1, h->verbose);
807 h->num_frames = oc->frame_number; 805 h->num_frames = oc->frame_number;
825 signal_sdl_exit(h); 823 signal_sdl_exit(h);
826 pthread_join(sdl_thr, NULL); 824 pthread_join(sdl_thr, NULL);
827 } 825 }
828 #endif 826 #endif
829 827
830 VSs__end_thread( animSlv ); 828 return 0;
831 } 829 }