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

comparison libavcodec/h264_ompss.c @ 9:ea1ba68cf0ed

find changesets by author, revision, files, or words in the commit message
update to match api changes + add sscc produced source
author Nina Engelhardt <nengel@mailbox.tu-berlin.de>
date Wed, 05 Jun 2013 14:43:26 +0200
parents 6c1433f5a562
children
comparison
equal deleted inserted replaced
6:d4d9503bce2b 7:3e3b3d3252c4
34 NalContext *nc; 34 NalContext *nc;
35 SliceBufferEntry *sbe; 35 SliceBufferEntry *sbe;
36 H264Context *h; 36 H264Context *h;
37 } parse_taskArgs; 37 } parse_taskArgs;
38 38
39 int32 parse_taskArgTypes[4] = {INOUT, INOUT, OUTPUT, NONCTLD}; 39 int32 parse_taskArgTypes[3] = {INOUT, INOUT, OUTPUT};
40 int32 parse_taskArgSizes[4] = {sizeof(ParserContext), sizeof(NalContext), sizeof(SliceBufferEntry), sizeof(H264Context)}; 40 size_t parse_taskArgSizes[3] = {sizeof(ParserContext), sizeof(NalContext), sizeof(SliceBufferEntry)};
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){ 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;
61 return; 61 return;
62 } 62 }
63 63
64 VSsTaskType parse_taskType = { 64 VSsTaskType parse_taskType = {
65 .fn = &parse_task, 65 .fn = &parse_task,
66 .numCtldArgs = 3, 66 .numDeps = 3,
67 .numTotalArgs = 4,
68 .sizeOfArgs = sizeof(parse_taskArgs), 67 .sizeOfArgs = sizeof(parse_taskArgs),
69 .argTypes = parse_taskArgTypes, 68 .depsTypes = parse_taskArgTypes,
70 .argSizes = parse_taskArgSizes}; 69 .depsSizes = parse_taskArgSizes};
71 70
72 71
73 typedef struct{ 72 typedef struct{
74 EntropyContext *ec; 73 EntropyContext *ec;
75 SliceBufferEntry *sbe; 74 SliceBufferEntry *sbe;
76 H264Context *h; 75 H264Context *h;
77 } decode_slice_entropy_taskArgs; 76 } decode_slice_entropy_taskArgs;
78 77
79 int32 decode_slice_entropy_taskArgTypes[3] = {INOUT, INOUT, NONCTLD}; 78 int32 decode_slice_entropy_taskArgTypes[2] = {INOUT, INOUT};
80 int32 decode_slice_entropy_taskArgSizes[3] = {sizeof(EntropyContext), sizeof(SliceBufferEntry), sizeof(H264Context)}; 79 size_t decode_slice_entropy_taskArgSizes[2] = {sizeof(EntropyContext), sizeof(SliceBufferEntry)};
81 80
82 //#pragma omp task inout(*ec) inout(*sbe) 81 //#pragma omp task inout(*ec) inout(*sbe)
83 static void decode_slice_entropy_task(void *_data){ 82 static void decode_slice_entropy_task(void *_data){
84 decode_slice_entropy_taskArgs* args = (decode_slice_entropy_taskArgs*) _data; 83 decode_slice_entropy_taskArgs* args = (decode_slice_entropy_taskArgs*) _data;
85 EntropyContext *ec = args->ec; 84 EntropyContext *ec = args->ec;
131 return; 130 return;
132 } 131 }
133 132
134 VSsTaskType decode_slice_entropy_taskType = { 133 VSsTaskType decode_slice_entropy_taskType = {
135 .fn = &decode_slice_entropy_task, 134 .fn = &decode_slice_entropy_task,
136 .numCtldArgs = 2, 135 .numDeps = 2,
137 .numTotalArgs = 3,
138 .sizeOfArgs = sizeof(decode_slice_entropy_taskArgs), 136 .sizeOfArgs = sizeof(decode_slice_entropy_taskArgs),
139 .argTypes = decode_slice_entropy_taskArgTypes, 137 .depsTypes = decode_slice_entropy_taskArgTypes,
140 .argSizes = decode_slice_entropy_taskArgSizes}; 138 .depsSizes = decode_slice_entropy_taskArgSizes};
141 139
142 140
143 static void decode_super_mb_block(MBRecContext *d, H264Slice *s, SuperMBContext *smbc, H264Mb *mbs, int smb_x, int smb_y){ 141 static void decode_super_mb_block(MBRecContext *d, H264Slice *s, SuperMBContext *smbc, H264Mb *mbs, int smb_x, int smb_y){
144 MBRecState mrs; 142 MBRecState mrs;
145 // memset(&mrs, 0, sizeof(MBRecState)); 143 // memset(&mrs, 0, sizeof(MBRecState));
161 SuperMBTask *mur; 159 SuperMBTask *mur;
162 SuperMBTask *m; 160 SuperMBTask *m;
163 SuperMBContext *smbc; 161 SuperMBContext *smbc;
164 } decode_super_mb_taskArgs; 162 } decode_super_mb_taskArgs;
165 163
166 int32 decode_super_mb_taskArgTypes[6] = {IN, IN, IN, IN, INOUT, NONCTLD}; 164 int32 decode_super_mb_taskArgTypes[5] = {IN, IN, IN, IN, INOUT};
167 int32 decode_super_mb_taskArgSizes[6] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBContext)}; 165 size_t decode_super_mb_taskArgSizes[5] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask)};
168 166
169 //#pragma omp task input(*d, *sbe, *ml, *mur) inout(*m) 167 //#pragma omp task input(*d, *sbe, *ml, *mur) inout(*m)
170 static void decode_super_mb_task(void *_data){ 168 static void decode_super_mb_task(void *_data){
171 decode_super_mb_taskArgs* args = (decode_super_mb_taskArgs*) _data; 169 decode_super_mb_taskArgs* args = (decode_super_mb_taskArgs*) _data;
172 MBRecContext *d = args->d; 170 MBRecContext *d = args->d;
181 return; 179 return;
182 } 180 }
183 181
184 VSsTaskType decode_super_mb_taskType = { 182 VSsTaskType decode_super_mb_taskType = {
185 .fn = &decode_super_mb_task, 183 .fn = &decode_super_mb_task,
186 .numCtldArgs = 5, 184 .numDeps = 5,
187 .numTotalArgs = 6,
188 .sizeOfArgs = sizeof(decode_super_mb_taskArgs), 185 .sizeOfArgs = sizeof(decode_super_mb_taskArgs),
189 .argTypes = decode_super_mb_taskArgTypes, 186 .depsTypes = decode_super_mb_taskArgTypes,
190 .argSizes = decode_super_mb_taskArgSizes}; 187 .depsSizes = decode_super_mb_taskArgSizes};
191 188
192 189
193 190
194 typedef struct{ 191 typedef struct{
195 MBRecContext *d; 192 MBRecContext *d;
197 SuperMBTask *sm; 194 SuperMBTask *sm;
198 SuperMBContext *smbc; 195 SuperMBContext *smbc;
199 int* line; 196 int* line;
200 } draw_edges_taskArgs; 197 } draw_edges_taskArgs;
201 198
202 int32 draw_edges_taskArgTypes[5] = {IN, IN, INOUT, NONCTLD, NONCTLD}; 199 int32 draw_edges_taskArgTypes[3] = {IN, IN, INOUT};
203 int32 draw_edges_taskArgSizes[5] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask),sizeof(SuperMBContext),sizeof(int)}; 200 size_t draw_edges_taskArgSizes[3] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask)};
204 201
205 //#pragma omp task input(*d, *sbe) inout(*sm) 202 //#pragma omp task input(*d, *sbe) inout(*sm)
206 static void draw_edges_task(void *_data){ 203 static void draw_edges_task(void *_data){
207 draw_edges_taskArgs* args = (draw_edges_taskArgs*) _data; 204 draw_edges_taskArgs* args = (draw_edges_taskArgs*) _data;
208 MBRecContext *d = args->d; 205 MBRecContext *d = args->d;
216 VMS_App__free(args->line); 213 VMS_App__free(args->line);
217 return; 214 return;
218 } 215 }
219 VSsTaskType draw_edges_taskType = { 216 VSsTaskType draw_edges_taskType = {
220 .fn = &draw_edges_task, 217 .fn = &draw_edges_task,
221 .numCtldArgs = 3, 218 .numDeps = 3,
222 .numTotalArgs = 5,
223 .sizeOfArgs = sizeof(draw_edges_taskArgs), 219 .sizeOfArgs = sizeof(draw_edges_taskArgs),
224 .argTypes = draw_edges_taskArgTypes, 220 .depsTypes = draw_edges_taskArgTypes,
225 .argSizes = draw_edges_taskArgSizes}; 221 .depsSizes = draw_edges_taskArgSizes};
226 222
227 223
228 static void decode_mb_in_slice(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe){ 224 static void decode_mb_in_slice(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe){
229 int i,j; 225 int i,j;
230 226
243 decode_super_mb_task_args.sbe = sbe; 239 decode_super_mb_task_args.sbe = sbe;
244 decode_super_mb_task_args.smbc = smbc; 240 decode_super_mb_task_args.smbc = smbc;
245 decode_super_mb_task_args.ml = sml; 241 decode_super_mb_task_args.ml = sml;
246 decode_super_mb_task_args.mur = smur; 242 decode_super_mb_task_args.mur = smur;
247 decode_super_mb_task_args.m = sm; 243 decode_super_mb_task_args.m = sm;
248 VSs__submit_task(&decode_super_mb_taskType, &decode_super_mb_task_args); 244 void** depsAddrs = malloc(decode_super_mb_taskType.numDeps * sizeof(void*));
245 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask)*/
246 depsAddrs[0] = d;
247 depsAddrs[1] = sbe;
248 depsAddrs[2] = sml;
249 depsAddrs[3] = smur;
250 depsAddrs[4] = sm;
251 VSs__submit_task(&decode_super_mb_taskType, &decode_super_mb_task_args, depsAddrs);
249 } 252 }
250 draw_edges_taskArgs draw_edges_task_args; 253 draw_edges_taskArgs draw_edges_task_args;
251 draw_edges_task_args.d = d; 254 draw_edges_task_args.d = d;
252 draw_edges_task_args.sbe = sbe; 255 draw_edges_task_args.sbe = sbe;
253 draw_edges_task_args.sm = sm; 256 draw_edges_task_args.sm = sm;
254 draw_edges_task_args.smbc = smbc; 257 draw_edges_task_args.smbc = smbc;
255 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) ); 258 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) );
256 *(draw_edges_task_args.line) = j; 259 *(draw_edges_task_args.line) = j;
257 VSs__submit_task(&draw_edges_taskType, &draw_edges_task_args); 260 void** depsAddrs = malloc(sizeof (void*) * draw_edges_taskType.numDeps);
261 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask)*/
262 depsAddrs[0] = d;
263 depsAddrs[1] = sbe;
264 depsAddrs[2] = sm;
265 VSs__submit_task(&draw_edges_taskType, &draw_edges_task_args, depsAddrs);
258 } 266 }
259 VSs__taskwait_on(sm); 267 VSs__taskwait_on(sm);
260 //#pragma omp taskwait on(*sm) 268 //#pragma omp taskwait on(*sm)
261 269
262 release_smbc(h, smbc); 270 release_smbc(h, smbc);
266 MBRecContext *d; 274 MBRecContext *d;
267 SliceBufferEntry *sbe; 275 SliceBufferEntry *sbe;
268 H264Context *h; 276 H264Context *h;
269 } decode_slice_mb_taskArgs; 277 } decode_slice_mb_taskArgs;
270 278
271 int32 decode_slice_mb_taskArgTypes[3] = {INOUT, INOUT, NONCTLD}; 279 int32 decode_slice_mb_taskArgTypes[2] = {INOUT, INOUT};
272 int32 decode_slice_mb_taskArgSizes[3] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(H264Context)}; 280 size_t decode_slice_mb_taskArgSizes[2] = {sizeof(MBRecContext), sizeof(SliceBufferEntry)};
273 281
274 //#pragma omp task inout(*d) inout(*sbe) 282 //#pragma omp task inout(*d) inout(*sbe)
275 static void decode_slice_mb_task(void *_data){ 283 static void decode_slice_mb_task(void *_data){
276 decode_slice_mb_taskArgs* args = (decode_slice_mb_taskArgs*) _data; 284 decode_slice_mb_taskArgs* args = (decode_slice_mb_taskArgs*) _data;
277 MBRecContext *d = args->d; 285 MBRecContext *d = args->d;
318 return; 326 return;
319 } 327 }
320 328
321 VSsTaskType decode_slice_mb_taskType = { 329 VSsTaskType decode_slice_mb_taskType = {
322 .fn = &decode_slice_mb_task, 330 .fn = &decode_slice_mb_task,
323 .numCtldArgs = 2, 331 .numDeps = 2,
324 .numTotalArgs = 3,
325 .sizeOfArgs = sizeof(decode_slice_mb_taskArgs), 332 .sizeOfArgs = sizeof(decode_slice_mb_taskArgs),
326 .argTypes = decode_slice_mb_taskArgTypes, 333 .depsTypes = decode_slice_mb_taskArgTypes,
327 .argSizes = decode_slice_mb_taskArgSizes}; 334 .depsSizes = decode_slice_mb_taskArgSizes};
328 335
329 // for static 3d wave 336 // for static 3d wave
330 /*-------------------------------------------------------------------------------*/ 337 /*-------------------------------------------------------------------------------*/
331 typedef struct{ 338 typedef struct{
332 MBRecContext *d; 339 MBRecContext *d;
336 SuperMBTask *mprev; 343 SuperMBTask *mprev;
337 SuperMBTask *m; 344 SuperMBTask *m;
338 SuperMBContext *smbc; 345 SuperMBContext *smbc;
339 } decode_3dwave_super_mb_taskArgs; 346 } decode_3dwave_super_mb_taskArgs;
340 347
341 int32 decode_3dwave_super_mb_taskArgTypes[7] = {IN, IN, IN, IN, IN, INOUT, NONCTLD}; 348 int32 decode_3dwave_super_mb_taskArgTypes[6] = {IN, IN, IN, IN, IN, INOUT};
342 int32 decode_3dwave_super_mb_taskArgSizes[7] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), 349 size_t decode_3dwave_super_mb_taskArgSizes[6] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask),
343 sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBContext)}; 350 sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask)};
344 351
345 //#pragma omp task input(*d, *sbe, *ml, *mur, *mprev) inout(*m) 352 //#pragma omp task input(*d, *sbe, *ml, *mur, *mprev) inout(*m)
346 static void decode_3dwave_super_mb_task(void *_data){ 353 static void decode_3dwave_super_mb_task(void *_data){
347 decode_3dwave_super_mb_taskArgs* args = (decode_3dwave_super_mb_taskArgs*) _data; 354 decode_3dwave_super_mb_taskArgs* args = (decode_3dwave_super_mb_taskArgs*) _data;
348 MBRecContext *d = args->d; 355 MBRecContext *d = args->d;
360 return; 367 return;
361 } 368 }
362 369
363 VSsTaskType decode_3dwave_super_mb_taskType = { 370 VSsTaskType decode_3dwave_super_mb_taskType = {
364 .fn = &decode_3dwave_super_mb_task, 371 .fn = &decode_3dwave_super_mb_task,
365 .numCtldArgs = 6, 372 .numDeps = 6,
366 .numTotalArgs = 7,
367 .sizeOfArgs = sizeof(decode_3dwave_super_mb_taskArgs), 373 .sizeOfArgs = sizeof(decode_3dwave_super_mb_taskArgs),
368 .argTypes = decode_3dwave_super_mb_taskArgTypes, 374 .depsTypes = decode_3dwave_super_mb_taskArgTypes,
369 .argSizes = decode_3dwave_super_mb_taskArgSizes}; 375 .depsSizes = decode_3dwave_super_mb_taskArgSizes};
370 376
371 // int init_ref_count=0; 377 // int init_ref_count=0;
372 typedef struct{ 378 typedef struct{
373 MBRecContext *d; 379 MBRecContext *d;
374 SliceBufferEntry *sbe; 380 SliceBufferEntry *sbe;
375 int* init; 381 int* init;
376 H264Context *h; 382 H264Context *h;
377 } init_ref_list_and_get_dpb_taskArgs; 383 } init_ref_list_and_get_dpb_taskArgs;
378 384
379 int32 init_ref_list_and_get_dpb_taskArgTypes[4] = {INOUT, INOUT, INOUT, NONCTLD}; 385 int32 init_ref_list_and_get_dpb_taskArgTypes[3] = {INOUT, INOUT, INOUT};
380 int32 init_ref_list_and_get_dpb_taskArgSizes[4] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(int), sizeof(H264Context)}; 386 size_t init_ref_list_and_get_dpb_taskArgSizes[3] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(int)};
381 387
382 //#pragma omp task inout(*d, *sbe, *init) 388 //#pragma omp task inout(*d, *sbe, *init)
383 static void init_ref_list_and_get_dpb_task(void *_data){ 389 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; 390 init_ref_list_and_get_dpb_taskArgs* args = (init_ref_list_and_get_dpb_taskArgs*) _data;
385 MBRecContext *d = args->d; 391 MBRecContext *d = args->d;
410 return; 416 return;
411 } 417 }
412 418
413 VSsTaskType init_ref_list_and_get_dpb_taskType = { 419 VSsTaskType init_ref_list_and_get_dpb_taskType = {
414 .fn = &init_ref_list_and_get_dpb_task, 420 .fn = &init_ref_list_and_get_dpb_task,
415 .numCtldArgs = 3, 421 .numDeps = 3,
416 .numTotalArgs = 4,
417 .sizeOfArgs = sizeof(init_ref_list_and_get_dpb_taskArgs), 422 .sizeOfArgs = sizeof(init_ref_list_and_get_dpb_taskArgs),
418 .argTypes = init_ref_list_and_get_dpb_taskArgTypes, 423 .depsTypes = init_ref_list_and_get_dpb_taskArgTypes,
419 .argSizes = init_ref_list_and_get_dpb_taskArgSizes}; 424 .depsSizes = init_ref_list_and_get_dpb_taskArgSizes};
420 425
421 static SuperMBTask* add_decode_slice_3dwave_tasks(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, int k){ 426 static SuperMBTask* add_decode_slice_3dwave_tasks(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, int k){
422 int i,j; 427 int i,j;
423 428
424 int32* taskID; 429 int32* taskID;
444 decode_3dwave_super_mb_task_args.ml = sml; 449 decode_3dwave_super_mb_task_args.ml = sml;
445 decode_3dwave_super_mb_task_args.mur = smur; 450 decode_3dwave_super_mb_task_args.mur = smur;
446 decode_3dwave_super_mb_task_args.mprev = smprev; 451 decode_3dwave_super_mb_task_args.mprev = smprev;
447 decode_3dwave_super_mb_task_args.m = sm; 452 decode_3dwave_super_mb_task_args.m = sm;
448 taskID = VSs__create_taskID_of_size(3 ); 453 taskID = VSs__create_taskID_of_size(3 );
454 void** depsAddrs = malloc(sizeof(void*) * decode_3dwave_super_mb_taskType.numDeps);
455 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask),
456 sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask)*/
457 depsAddrs[0] = d;
458 depsAddrs[1] = sbe;
459 depsAddrs[2] = sml;
460 depsAddrs[3] = smur;
461 depsAddrs[4] = smprev;
449 taskID[1] = k; 462 taskID[1] = k;
450 taskID[2] = j; 463 taskID[2] = j;
451 taskID[3] = i; 464 taskID[3] = i;
452 VSs__submit_task_with_ID(&decode_3dwave_super_mb_taskType, &decode_3dwave_super_mb_task_args, taskID); 465 VSs__submit_task_with_ID(&decode_3dwave_super_mb_taskType, &decode_3dwave_super_mb_task_args, depsAddrs, taskID);
453 } 466 }
454 draw_edges_taskArgs draw_edges_task_args; 467 draw_edges_taskArgs draw_edges_task_args;
455 draw_edges_task_args.d = d; 468 draw_edges_task_args.d = d;
456 draw_edges_task_args.sbe = sbe; 469 draw_edges_task_args.sbe = sbe;
457 draw_edges_task_args.sm = sm; 470 draw_edges_task_args.sm = sm;
458 draw_edges_task_args.smbc = smbc; 471 draw_edges_task_args.smbc = smbc;
459 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) ); 472 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) );
460 *(draw_edges_task_args.line) = j; 473 *(draw_edges_task_args.line) = j;
474 void** depsAddrs = malloc(sizeof (void*) * draw_edges_taskType.numDeps);
475 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask)*/
476 depsAddrs[0] = d;
477 depsAddrs[1] = sbe;
478 depsAddrs[2] = sm;
461 taskID = VSs__create_taskID_of_size(3); 479 taskID = VSs__create_taskID_of_size(3);
462 taskID[1] = k; 480 taskID[1] = k;
463 taskID[2] = j; 481 taskID[2] = j;
464 taskID[3] = i; 482 taskID[3] = i;
465 VSs__submit_task_with_ID(&draw_edges_taskType, &draw_edges_task_args, taskID); 483 VSs__submit_task_with_ID(&draw_edges_taskType, &draw_edges_task_args, depsAddrs, taskID);
466 } 484 }
467 485
468 for(; j< smb_height; j++){ 486 for(; j< smb_height; j++){
469 for(i=0; i< smb_width; i++){ 487 for(i=0; i< smb_width; i++){
470 sm = smbs + j*smb_width + i; 488 sm = smbs + j*smb_width + i;
475 decode_super_mb_task_args.sbe = sbe; 493 decode_super_mb_task_args.sbe = sbe;
476 decode_super_mb_task_args.smbc = smbc; 494 decode_super_mb_task_args.smbc = smbc;
477 decode_super_mb_task_args.ml = sml; 495 decode_super_mb_task_args.ml = sml;
478 decode_super_mb_task_args.mur = smur; 496 decode_super_mb_task_args.mur = smur;
479 decode_super_mb_task_args.m = sm; 497 decode_super_mb_task_args.m = sm;
498 void** depsAddrs = malloc(sizeof(void*) * decode_super_mb_taskType.numDeps);
499 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask)*/
500 depsAddrs[0] = d;
501 depsAddrs[1] = sbe;
502 depsAddrs[2] = sml;
503 depsAddrs[3] = smur;
504 depsAddrs[4] = sm;
480 taskID = VSs__create_taskID_of_size(3 ); 505 taskID = VSs__create_taskID_of_size(3 );
481 taskID[1] = k; 506 taskID[1] = k;
482 taskID[2] = j; 507 taskID[2] = j;
483 taskID[3] = i; 508 taskID[3] = i;
484 VSs__submit_task_with_ID(&decode_super_mb_taskType, &decode_super_mb_task_args, taskID); 509 VSs__submit_task_with_ID(&decode_super_mb_taskType, &decode_super_mb_task_args, depsAddrs, taskID);
485 } 510 }
486 draw_edges_taskArgs draw_edges_task_args; 511 draw_edges_taskArgs draw_edges_task_args;
487 draw_edges_task_args.d = d; 512 draw_edges_task_args.d = d;
488 draw_edges_task_args.sbe = sbe; 513 draw_edges_task_args.sbe = sbe;
489 draw_edges_task_args.sm = sm; 514 draw_edges_task_args.sm = sm;
490 draw_edges_task_args.smbc = smbc; 515 draw_edges_task_args.smbc = smbc;
491 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) ); 516 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) );
492 *(draw_edges_task_args.line) = j; 517 *(draw_edges_task_args.line) = j;
518 void** depsAddrs = malloc(sizeof (void*) * draw_edges_taskType.numDeps);
519 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask)*/
520 depsAddrs[0] = d;
521 depsAddrs[1] = sbe;
522 depsAddrs[2] = sm;
493 taskID = VSs__create_taskID_of_size(3); 523 taskID = VSs__create_taskID_of_size(3);
494 taskID[1] = k; 524 taskID[1] = k;
495 taskID[2] = j; 525 taskID[2] = j;
496 taskID[3] = i; 526 taskID[3] = i;
497 VSs__submit_task_with_ID(&draw_edges_taskType, &draw_edges_task_args, taskID); 527 VSs__submit_task_with_ID(&draw_edges_taskType, &draw_edges_task_args, depsAddrs, taskID);
498 } 528 }
499 return sm; 529 return sm;
500 } 530 }
501 531
502 typedef struct{ 532 typedef struct{
506 int* release; 536 int* release;
507 H264Context *h; 537 H264Context *h;
508 SuperMBContext *smbc; 538 SuperMBContext *smbc;
509 } release_ref_list_taskArgs; 539 } release_ref_list_taskArgs;
510 540
511 int32 release_ref_list_taskArgTypes[6] = {INOUT, INOUT, IN, INOUT, NONCTLD, NONCTLD}; 541 int32 release_ref_list_taskArgTypes[4] = {INOUT, INOUT, IN, INOUT};
512 int32 release_ref_list_taskArgSizes[6] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(int), sizeof(H264Context), sizeof(SuperMBContext)}; 542 size_t release_ref_list_taskArgSizes[4] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(int)};
513 543
514 //#pragma omp task inout(*d, *sbe, *release) input (*lastsmb) 544 //#pragma omp task inout(*d, *sbe, *release) input (*lastsmb)
515 static void release_ref_list_task(void *_data){ 545 static void release_ref_list_task(void *_data){
516 release_ref_list_taskArgs* args = (release_ref_list_taskArgs*) _data; 546 release_ref_list_taskArgs* args = (release_ref_list_taskArgs*) _data;
517 MBRecContext *d = args->d; 547 MBRecContext *d = args->d;
540 return; 570 return;
541 } 571 }
542 572
543 VSsTaskType release_ref_list_taskType = { 573 VSsTaskType release_ref_list_taskType = {
544 .fn = &release_ref_list_task, 574 .fn = &release_ref_list_task,
545 .numCtldArgs = 4, 575 .numDeps = 4,
546 .numTotalArgs = 6,
547 .sizeOfArgs = sizeof(release_ref_list_taskArgs), 576 .sizeOfArgs = sizeof(release_ref_list_taskArgs),
548 .argTypes = release_ref_list_taskArgTypes, 577 .depsTypes = release_ref_list_taskArgTypes,
549 .argSizes = release_ref_list_taskArgSizes}; 578 .depsSizes = release_ref_list_taskArgSizes};
550 579
551 // static void decode_mb_static_3dwave(H264Context *h, int mb_height, int mb_width, MBRecContext *d, H264Slice *s, H264Mb *mbs, SuperMBTask *smbs, SuperMBTask *smbs_prev){ 580 // static void decode_mb_static_3dwave(H264Context *h, int mb_height, int mb_width, MBRecContext *d, H264Slice *s, H264Mb *mbs, SuperMBTask *smbs, SuperMBTask *smbs_prev){
552 // 581 //
553 // } 582 // }
554 /*-------------------------------------------------------------------------------*/ 583 /*-------------------------------------------------------------------------------*/
558 OutputContext *oc; 587 OutputContext *oc;
559 SliceBufferEntry *sbe; 588 SliceBufferEntry *sbe;
560 H264Context *h; 589 H264Context *h;
561 } output_taskArgs; 590 } output_taskArgs;
562 591
563 int32 output_taskArgTypes[3] = {INOUT, IN, NONCTLD}; 592 int32 output_taskArgTypes[2] = {INOUT, IN};
564 int32 output_taskArgSizes[3] = {sizeof(OutputContext), sizeof(SliceBufferEntry), sizeof(H264Context)}; 593 size_t output_taskArgSizes[2] = {sizeof(OutputContext), sizeof(SliceBufferEntry)};
565 594
566 //#pragma omp task inout (*oc) input(*sbe) 595 //#pragma omp task inout (*oc) input(*sbe)
567 static void output_task(void *_data){ 596 static void output_task(void *_data){
568 output_taskArgs* args = (output_taskArgs*) _data; 597 output_taskArgs* args = (output_taskArgs*) _data;
569 OutputContext *oc = args->oc; 598 OutputContext *oc = args->oc;
582 return; 611 return;
583 } 612 }
584 613
585 VSsTaskType output_taskType = { 614 VSsTaskType output_taskType = {
586 .fn = &output_task, 615 .fn = &output_task,
587 .numCtldArgs = 2, 616 .numDeps = 2,
588 .numTotalArgs = 3,
589 .sizeOfArgs = sizeof(output_taskArgs), 617 .sizeOfArgs = sizeof(output_taskArgs),
590 .argTypes = output_taskArgTypes, 618 .depsTypes = output_taskArgTypes,
591 .argSizes = output_taskArgSizes}; 619 .depsSizes = output_taskArgSizes};
592 620
593 /* 621 /*
594 * The following code is the main loop of the file converter 622 * The following code is the main loop of the file converter
595 */ 623 */
596 624
608 636
609 DecodedPicture *out; 637 DecodedPicture *out;
610 int frames=0; 638 int frames=0;
611 639
612 int32* taskID; 640 int32* taskID;
641 void** depsAddrs;
613 642
614 #if HAVE_LIBSDL2 643 #if HAVE_LIBSDL2
615 pthread_t sdl_thr; 644 pthread_t sdl_thr;
616 if (h->display){ 645 if (h->display){
617 pthread_create(&sdl_thr, NULL, sdl_thread, h); 646 pthread_create(&sdl_thr, NULL, sdl_thread, h);
643 parse_taskArgs parse_task_args; 672 parse_taskArgs parse_task_args;
644 parse_task_args.h = h; 673 parse_task_args.h = h;
645 parse_task_args.pc = pc; 674 parse_task_args.pc = pc;
646 parse_task_args.nc = nc; 675 parse_task_args.nc = nc;
647 parse_task_args.sbe = &sbe[k%bufs]; 676 parse_task_args.sbe = &sbe[k%bufs];
677 depsAddrs = malloc(sizeof(void*) * parse_taskType.numDeps);
678 /*sizeof(ParserContext), sizeof(NalContext), sizeof(SliceBufferEntry)*/
679 depsAddrs[0] = pc;
680 depsAddrs[1] = nc;
681 depsAddrs[2] = &sbe[k%bufs];
648 taskID = VSs__create_taskID_of_size(2); 682 taskID = VSs__create_taskID_of_size(2);
649 taskID[1] = 1; 683 taskID[1] = 1;
650 taskID[2] = k; 684 taskID[2] = k;
651 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, taskID); 685 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, depsAddrs, taskID);
652 686
653 decode_slice_entropy_taskArgs decode_slice_entropy_task_args; 687 decode_slice_entropy_taskArgs decode_slice_entropy_task_args;
654 decode_slice_entropy_task_args.h = h; 688 decode_slice_entropy_task_args.h = h;
655 decode_slice_entropy_task_args.ec = ec[k%bufs]; 689 decode_slice_entropy_task_args.ec = ec[k%bufs];
656 decode_slice_entropy_task_args.sbe = &sbe[k%bufs]; 690 decode_slice_entropy_task_args.sbe = &sbe[k%bufs];
691 depsAddrs = malloc(sizeof(void*) * decode_slice_entropy_taskType.numDeps);
692 /*sizeof(EntropyContext), sizeof(SliceBufferEntry)*/
693 depsAddrs[0] = ec[k%bufs];
694 depsAddrs[1] = &sbe[k%bufs];
657 taskID = VSs__create_taskID_of_size(2); 695 taskID = VSs__create_taskID_of_size(2);
658 taskID[1] = 2; 696 taskID[1] = 2;
659 taskID[2] = k; 697 taskID[2] = k;
660 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, taskID); 698 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, depsAddrs, taskID);
661 //#pragma omp taskwait on(*pc) 699 //#pragma omp taskwait on(*pc)
662 VSs__taskwait_on(pc); 700 VSs__taskwait_on(pc);
663 k++; 701 k++;
664 } 702 }
665 703
667 parse_taskArgs parse_task_args; 705 parse_taskArgs parse_task_args;
668 parse_task_args.h = h; 706 parse_task_args.h = h;
669 parse_task_args.pc = pc; 707 parse_task_args.pc = pc;
670 parse_task_args.nc = nc; 708 parse_task_args.nc = nc;
671 parse_task_args.sbe = &sbe[k%bufs]; 709 parse_task_args.sbe = &sbe[k%bufs];
710 depsAddrs = malloc(sizeof(void*) * parse_taskType.numDeps);
711 /*sizeof(ParserContext), sizeof(NalContext), sizeof(SliceBufferEntry)*/
712 depsAddrs[0] = pc;
713 depsAddrs[1] = nc;
714 depsAddrs[2] = &sbe[k%bufs];
672 taskID = VSs__create_taskID_of_size(2); 715 taskID = VSs__create_taskID_of_size(2);
673 taskID[1] = 3; 716 taskID[1] = 3;
674 taskID[2] = k; 717 taskID[2] = k;
675 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, taskID); 718 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, depsAddrs, taskID);
676 719
677 decode_slice_entropy_taskArgs decode_slice_entropy_task_args; 720 decode_slice_entropy_taskArgs decode_slice_entropy_task_args;
678 decode_slice_entropy_task_args.h = h; 721 decode_slice_entropy_task_args.h = h;
679 decode_slice_entropy_task_args.ec = ec[k%bufs]; 722 decode_slice_entropy_task_args.ec = ec[k%bufs];
680 decode_slice_entropy_task_args.sbe = &sbe[k%bufs]; 723 decode_slice_entropy_task_args.sbe = &sbe[k%bufs];
724 depsAddrs = malloc(sizeof(void*) * decode_slice_entropy_taskType.numDeps);
725 /*sizeof(EntropyContext), sizeof(SliceBufferEntry)*/
726 depsAddrs[0] = ec[k%bufs];
727 depsAddrs[1] = &sbe[k%bufs];
681 taskID = VSs__create_taskID_of_size(2); 728 taskID = VSs__create_taskID_of_size(2);
682 taskID[1] = 4; 729 taskID[1] = 4;
683 taskID[2] = k; 730 taskID[2] = k;
684 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, taskID); 731 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, depsAddrs, taskID);
685 732
686 k++; 733 k++;
687 734
688 init_ref_list_and_get_dpb_taskArgs init_ref_list_and_get_dpb_task_args; 735 init_ref_list_and_get_dpb_taskArgs init_ref_list_and_get_dpb_task_args;
689 init_ref_list_and_get_dpb_task_args.h = h; 736 init_ref_list_and_get_dpb_task_args.h = h;
690 init_ref_list_and_get_dpb_task_args.d = rc[k%2]; 737 init_ref_list_and_get_dpb_task_args.d = rc[k%2];
691 init_ref_list_and_get_dpb_task_args.sbe = &sbe[k%bufs]; 738 init_ref_list_and_get_dpb_task_args.sbe = &sbe[k%bufs];
692 init_ref_list_and_get_dpb_task_args.init = &init; 739 init_ref_list_and_get_dpb_task_args.init = &init;
740 depsAddrs = malloc(sizeof(void*) * init_ref_list_and_get_dpb_taskType.numDeps);
741 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(int)*/
742 depsAddrs[0] = rc[k%2];
743 depsAddrs[1] = &sbe[k%bufs];
744 depsAddrs[2] = &init;
693 taskID = VSs__create_taskID_of_size(2); 745 taskID = VSs__create_taskID_of_size(2);
694 taskID[1] = 5; 746 taskID[1] = 5;
695 taskID[2] = k; 747 taskID[2] = k;
696 VSs__submit_task_with_ID(&init_ref_list_and_get_dpb_taskType, &init_ref_list_and_get_dpb_task_args, taskID); 748 VSs__submit_task_with_ID(&init_ref_list_and_get_dpb_taskType, &init_ref_list_and_get_dpb_task_args, depsAddrs, taskID);
697 749
698 smbc = acquire_smbc(h); 750 smbc = acquire_smbc(h);
699 SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc, k); 751 SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc, k);
700 release_ref_list_taskArgs release_ref_list_task_args; 752 release_ref_list_taskArgs release_ref_list_task_args;
701 release_ref_list_task_args.h = h; 753 release_ref_list_task_args.h = h;
702 release_ref_list_task_args.smbc = smbc; 754 release_ref_list_task_args.smbc = smbc;
703 release_ref_list_task_args.d = rc[k%2]; 755 release_ref_list_task_args.d = rc[k%2];
704 release_ref_list_task_args.sbe = &sbe[k%bufs]; 756 release_ref_list_task_args.sbe = &sbe[k%bufs];
705 release_ref_list_task_args.lastsmb = lastsmb; 757 release_ref_list_task_args.lastsmb = lastsmb;
706 release_ref_list_task_args.release = &release; 758 release_ref_list_task_args.release = &release;
759 depsAddrs = malloc(sizeof(void*) * release_ref_list_taskType.numDeps);
760 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(int)*/
761 depsAddrs[0] = rc[k%2];
762 depsAddrs[1] = &sbe[k%bufs];
763 depsAddrs[2] = smbc;
764 depsAddrs[3] = &release;
707 taskID = VSs__create_taskID_of_size(2); 765 taskID = VSs__create_taskID_of_size(2);
708 taskID[1] = 6; 766 taskID[1] = 6;
709 taskID[2] = k; 767 taskID[2] = k;
710 VSs__submit_task_with_ID(&release_ref_list_taskType, &release_ref_list_task_args, taskID); 768 VSs__submit_task_with_ID(&release_ref_list_taskType, &release_ref_list_task_args, depsAddrs, taskID);
711 769
712 output_taskArgs output_task_args; 770 output_taskArgs output_task_args;
713 output_task_args.h = h; 771 output_task_args.h = h;
714 output_task_args.oc = oc; 772 output_task_args.oc = oc;
715 output_task_args.sbe = &sbe[k%bufs]; 773 output_task_args.sbe = &sbe[k%bufs];
774 depsAddrs = malloc(sizeof(void*) * output_taskType.numDeps);
775 /*sizeof(OutputContext), sizeof(SliceBufferEntry)*/
776 depsAddrs[0] = oc;
777 depsAddrs[1] = &sbe[k%bufs];
716 taskID = VSs__create_taskID_of_size(2); 778 taskID = VSs__create_taskID_of_size(2);
717 taskID[1] = 7; 779 taskID[1] = 7;
718 taskID[2] = k; 780 taskID[2] = k;
719 VSs__submit_task_with_ID(&output_taskType, &output_task_args, taskID); 781 VSs__submit_task_with_ID(&output_taskType, &output_task_args, depsAddrs, taskID);
720 //#pragma omp taskwait on(*pc) 782 //#pragma omp taskwait on(*pc)
721 VSs__taskwait_on(pc); 783 VSs__taskwait_on(pc);
722 } 784 }
723 785
724 for (int i=0; i< num_pre_ed; i++){ 786 for (int i=0; i< num_pre_ed; i++){
726 init_ref_list_and_get_dpb_taskArgs init_ref_list_and_get_dpb_task_args; 788 init_ref_list_and_get_dpb_taskArgs init_ref_list_and_get_dpb_task_args;
727 init_ref_list_and_get_dpb_task_args.h = h; 789 init_ref_list_and_get_dpb_task_args.h = h;
728 init_ref_list_and_get_dpb_task_args.d = rc[k%2]; 790 init_ref_list_and_get_dpb_task_args.d = rc[k%2];
729 init_ref_list_and_get_dpb_task_args.sbe = &sbe[k%bufs]; 791 init_ref_list_and_get_dpb_task_args.sbe = &sbe[k%bufs];
730 init_ref_list_and_get_dpb_task_args.init = &init; 792 init_ref_list_and_get_dpb_task_args.init = &init;
793 depsAddrs = malloc(sizeof(void*) * init_ref_list_and_get_dpb_taskType.numDeps);
794 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(int)*/
795 depsAddrs[0] = rc[k%2];
796 depsAddrs[1] = &sbe[k%bufs];
797 depsAddrs[2] = &init;
731 taskID = VSs__create_taskID_of_size(2); 798 taskID = VSs__create_taskID_of_size(2);
732 taskID[1] = 8; 799 taskID[1] = 8;
733 taskID[2] = i; 800 taskID[2] = i;
734 VSs__submit_task_with_ID(&init_ref_list_and_get_dpb_taskType, &init_ref_list_and_get_dpb_task_args, taskID); 801 VSs__submit_task_with_ID(&init_ref_list_and_get_dpb_taskType, &init_ref_list_and_get_dpb_task_args, depsAddrs, taskID);
735 smbc = acquire_smbc(h); 802 smbc = acquire_smbc(h);
736 SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc, k); 803 SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc, k);
737 release_ref_list_taskArgs release_ref_list_task_args; 804 release_ref_list_taskArgs release_ref_list_task_args;
738 release_ref_list_task_args.h = h; 805 release_ref_list_task_args.h = h;
739 release_ref_list_task_args.smbc = smbc; 806 release_ref_list_task_args.smbc = smbc;
740 release_ref_list_task_args.d = rc[k%2]; 807 release_ref_list_task_args.d = rc[k%2];
741 release_ref_list_task_args.sbe = &sbe[k%bufs]; 808 release_ref_list_task_args.sbe = &sbe[k%bufs];
742 release_ref_list_task_args.lastsmb = lastsmb; 809 release_ref_list_task_args.lastsmb = lastsmb;
743 release_ref_list_task_args.release = &release; 810 release_ref_list_task_args.release = &release;
811 depsAddrs = malloc(sizeof(void*) * release_ref_list_taskType.numDeps);
812 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(int)*/
813 depsAddrs[0] = rc[k%2];
814 depsAddrs[1] = &sbe[k%bufs];
815 depsAddrs[2] = smbc;
816 depsAddrs[3] = &release;
744 taskID = VSs__create_taskID_of_size(2); 817 taskID = VSs__create_taskID_of_size(2);
745 taskID[1] = 9; 818 taskID[1] = 9;
746 taskID[2] = k; 819 taskID[2] = k;
747 VSs__submit_task_with_ID(&release_ref_list_taskType, &release_ref_list_task_args, taskID); 820 VSs__submit_task_with_ID(&release_ref_list_taskType, &release_ref_list_task_args, depsAddrs, taskID);
748 821
749 output_taskArgs output_task_args; 822 output_taskArgs output_task_args;
750 output_task_args.h = h; 823 output_task_args.h = h;
751 output_task_args.oc = oc; 824 output_task_args.oc = oc;
752 output_task_args.sbe = &sbe[k%bufs]; 825 output_task_args.sbe = &sbe[k%bufs];
826 depsAddrs = malloc(sizeof(void*) * output_taskType.numDeps);
827 /*sizeof(OutputContext), sizeof(SliceBufferEntry)*/
828 depsAddrs[0] = oc;
829 depsAddrs[1] = &sbe[k%bufs];
753 taskID = VSs__create_taskID_of_size(2); 830 taskID = VSs__create_taskID_of_size(2);
754 taskID[1] = 10; 831 taskID[1] = 10;
755 taskID[2] = k; 832 taskID[2] = k;
756 VSs__submit_task_with_ID(&output_taskType, &output_task_args, taskID); 833 VSs__submit_task_with_ID(&output_taskType, &output_task_args, depsAddrs, taskID);
757 } 834 }
758 835
759 } else { 836 } else {
760 while(!pc->final_frame && frames++ < h->num_frames && !h->quit){ 837 while(!pc->final_frame && frames++ < h->num_frames && !h->quit){
761 838
764 parse_taskArgs parse_task_args; 841 parse_taskArgs parse_task_args;
765 parse_task_args.h = h; 842 parse_task_args.h = h;
766 parse_task_args.pc = pc; 843 parse_task_args.pc = pc;
767 parse_task_args.nc = nc; 844 parse_task_args.nc = nc;
768 parse_task_args.sbe = &sbe[k%bufs]; 845 parse_task_args.sbe = &sbe[k%bufs];
769 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, taskID); 846 depsAddrs = malloc(sizeof(void*) * parse_taskType.numDeps);
847 /*sizeof(ParserContext), sizeof(NalContext), sizeof(SliceBufferEntry)*/
848 depsAddrs[0] = pc;
849 depsAddrs[1] = nc;
850 depsAddrs[2] = &sbe[k%bufs];
851 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, depsAddrs, taskID);
770 852
771 taskID = VSs__create_taskID_of_size(1); 853 taskID = VSs__create_taskID_of_size(1);
772 taskID[1] = frames*10+2; 854 taskID[1] = frames*10+2;
773 decode_slice_entropy_taskArgs decode_slice_entropy_task_args; 855 decode_slice_entropy_taskArgs decode_slice_entropy_task_args;
774 decode_slice_entropy_task_args.h = h; 856 decode_slice_entropy_task_args.h = h;
775 decode_slice_entropy_task_args.ec = ec[k%bufs]; 857 decode_slice_entropy_task_args.ec = ec[k%bufs];
776 decode_slice_entropy_task_args.sbe = &sbe[k%bufs]; 858 decode_slice_entropy_task_args.sbe = &sbe[k%bufs];
777 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args,taskID); 859 depsAddrs = malloc(sizeof(void*) * decode_slice_entropy_taskType.numDeps);
860 /*sizeof(EntropyContext), sizeof(SliceBufferEntry)*/
861 depsAddrs[0] = ec[k%bufs];
862 depsAddrs[1] = &sbe[k%bufs];
863 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, depsAddrs, taskID);
778 864
779 taskID = VSs__create_taskID_of_size(1); 865 taskID = VSs__create_taskID_of_size(1);
780 taskID[1] = frames*10+3; 866 taskID[1] = frames*10+3;
781 decode_slice_mb_taskArgs decode_slice_mb_task_args; 867 decode_slice_mb_taskArgs decode_slice_mb_task_args;
782 decode_slice_mb_task_args.h = h; 868 decode_slice_mb_task_args.h = h;
783 decode_slice_mb_task_args.d = rc[0]; 869 decode_slice_mb_task_args.d = rc[0];
784 decode_slice_mb_task_args.sbe = &sbe[k%bufs]; 870 decode_slice_mb_task_args.sbe = &sbe[k%bufs];
785 VSs__submit_task_with_ID(&decode_slice_mb_taskType, &decode_slice_mb_task_args,taskID); 871 depsAddrs = malloc(sizeof(void*) * decode_slice_mb_taskType.numDeps);
872 /*sizeof(MBRecContext), sizeof(SliceBufferEntry)*/
873 depsAddrs[0] = rc[0];
874 depsAddrs[1] = &sbe[k%bufs];
875 VSs__submit_task_with_ID(&decode_slice_mb_taskType, &decode_slice_mb_task_args, depsAddrs, taskID);
786 876
787 taskID = VSs__create_taskID_of_size(1); 877 taskID = VSs__create_taskID_of_size(1);
788 taskID[1] = frames*10+4; 878 taskID[1] = frames*10+4;
789 output_taskArgs output_task_args; 879 output_taskArgs output_task_args;
790 output_task_args.h = h; 880 output_task_args.h = h;
791 output_task_args.oc = oc; 881 output_task_args.oc = oc;
792 output_task_args.sbe = &sbe[k%bufs]; 882 output_task_args.sbe = &sbe[k%bufs];
793 VSs__submit_task_with_ID(&output_taskType, &output_task_args,taskID); 883 depsAddrs = malloc(sizeof(void*) * output_taskType.numDeps);
884 /*sizeof(OutputContext), sizeof(SliceBufferEntry)*/
885 depsAddrs[0] = oc;
886 depsAddrs[1] = &sbe[k%bufs];
887 VSs__submit_task_with_ID(&output_taskType, &output_task_args, depsAddrs, taskID);
794 //#pragma omp taskwait on(*pc) 888 //#pragma omp taskwait on(*pc)
795 VSs__taskwait_on(pc); 889 VSs__taskwait_on(pc);
796 k++; 890 k++;
797 } 891 }
798 } 892 }