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

comparison libavcodec/h264_ompss.c @ 3:0b056460c67d

find changesets by author, revision, files, or words in the commit message
changed code to use VSs
author Nina Engelhardt <nengel@mailbox.tu-berlin.de>
date Mon, 29 Oct 2012 16:44:27 +0100
parents 897f711a7157
children 96e628866d41
comparison
equal deleted inserted replaced
0:cad5b3926624 1:69df04756016
25 #include "h264_rec.h" 25 #include "h264_rec.h"
26 #include "h264_pred_mode.h" 26 #include "h264_pred_mode.h"
27 #include "h264_misc.h" 27 #include "h264_misc.h"
28 // #undef NDEBUG 28 // #undef NDEBUG
29 #include <assert.h> 29 #include <assert.h>
30 30 #include "VSs_impl/VSs.h"
31 #pragma omp task inout(*pc, *nc) output(*sbe) 31
32 static void parse_task(H264Context *h, ParserContext *pc, NalContext *nc, SliceBufferEntry *sbe){ 32 typedef struct{
33 ParserContext *pc;
34 NalContext *nc;
35 SliceBufferEntry *sbe;
36 H264Context *h;
37 } parse_taskArgs;
38
39 int32 parse_taskArgTypes[4] = {INOUT, INOUT, OUTPUT, NONCTLD};
40 int32 parse_taskArgSizes[4] = {sizeof(ParserContext), sizeof(NalContext), sizeof(SliceBufferEntry), sizeof(H264Context)};
41
42 //#pragma omp task inout(*pc, *nc) output(*sbe)
43 static void parse_task(void *_data, SlaveVP *animatingSlv){
44 parse_taskArgs* args = (parse_taskArgs*) _data;
45 ParserContext *pc = args->pc;
46 NalContext *nc = args->nc;
47 SliceBufferEntry *sbe = args->sbe;
48 H264Context *h = args->h;
33 H264Slice *s; 49 H264Slice *s;
34 50
35 if (!sbe->initialized){ 51 if (!sbe->initialized){
36 init_sb_entry(h, sbe); 52 init_sb_entry(h, sbe);
37 sbe->lines_total=h->mb_height; 53 sbe->lines_total=h->mb_height;
39 55
40 av_read_frame_internal(pc, &sbe->gb); 56 av_read_frame_internal(pc, &sbe->gb);
41 s = &sbe->slice; 57 s = &sbe->slice;
42 58
43 decode_nal_units(nc, s, &sbe->gb); 59 decode_nal_units(nc, s, &sbe->gb);
44 } 60
45 61 VSs__end_task( animatingSlv );
46 #pragma omp task inout(*ec) inout(*sbe) 62 }
47 static void decode_slice_entropy_task(H264Context *h, EntropyContext *ec, SliceBufferEntry *sbe){ 63
64 VSsTaskType parse_taskType = {
65 .fn = &parse_task,
66 .numCtldArgs = 3,
67 .numTotalArgs = 4,
68 .sizeOfArgs = sizeof(parse_taskArgs),
69 .argTypes = parse_taskArgTypes,
70 .argSizes = parse_taskArgSizes};
71
72
73 typedef struct{
74 EntropyContext *ec;
75 SliceBufferEntry *sbe;
76 H264Context *h;
77 } decode_slice_entropy_taskArgs;
78
79 int32 decode_slice_entropy_taskArgTypes[3] = {INOUT, INOUT, NONCTLD};
80 int32 decode_slice_entropy_taskArgSizes[3] = {sizeof(EntropyContext), sizeof(SliceBufferEntry), sizeof(H264Context)};
81
82 //#pragma omp task inout(*ec) inout(*sbe)
83 static void decode_slice_entropy_task(void *_data, SlaveVP *animatingSlv){
84 decode_slice_entropy_taskArgs* args = (decode_slice_entropy_taskArgs*) _data;
85 EntropyContext *ec = args->ec;
86 SliceBufferEntry *sbe = args->sbe;
87 H264Context *h = args->h;
48 int i,j; 88 int i,j;
49 H264Slice *s = &sbe->slice; 89 H264Slice *s = &sbe->slice;
50 GetBitContext *gb = &sbe->gb; 90 GetBitContext *gb = &sbe->gb;
51 H264Mb *mbs = sbe->mbs; 91 H264Mb *mbs = sbe->mbs;
52 // GetBitContext *gb = s->gb; 92 // GetBitContext *gb = s->gb;
53 CABACContext *c = &ec->c; 93 CABACContext *c = &ec->c;
54 94
55 if( !s->pps.cabac ){ 95 if( !s->pps.cabac ){
56 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");
57 return ; 97 VSs__end_task( animatingSlv );
58 } 98 }
59 99
60 init_dequant_tables(s, ec); 100 init_dequant_tables(s, ec);
61 ec->curr_qscale = s->qscale; 101 ec->curr_qscale = s->qscale;
62 ec->last_qscale_diff = 0; 102 ec->last_qscale_diff = 0;
82 ret = ff_h264_decode_mb_cabac(ec, s, c); 122 ret = ff_h264_decode_mb_cabac(ec, s, c);
83 eos = get_cabac_terminate( c); 123 eos = get_cabac_terminate( c);
84 (void) eos; 124 (void) eos;
85 if( ret < 0 || c->bytestream > c->bytestream_end + 2) { 125 if( ret < 0 || c->bytestream > c->bytestream_end + 2) {
86 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);
87 return ; 127 VSs__end_task( animatingSlv );
88 } 128 }
89 } 129 }
90 } 130 }
91 } 131 VSs__end_task( animatingSlv );
132 }
133
134 VSsTaskType decode_slice_entropy_taskType = {
135 .fn = &decode_slice_entropy_task,
136 .numCtldArgs = 2,
137 .numTotalArgs = 3,
138 .sizeOfArgs = sizeof(decode_slice_entropy_taskArgs),
139 .argTypes = decode_slice_entropy_taskArgTypes,
140 .argSizes = decode_slice_entropy_taskArgSizes};
141
92 142
93 static void decode_super_mb_block(MBRecContext *d, H264Slice *s, SuperMBContext *smbc, H264Mb *mbs, int smb_x, int smb_y){ 143 static void decode_super_mb_block(MBRecContext *d, H264Slice *s, SuperMBContext *smbc, H264Mb *mbs, int smb_x, int smb_y){
94 MBRecState mrs; 144 MBRecState mrs;
95 // memset(&mrs, 0, sizeof(MBRecState)); 145 // memset(&mrs, 0, sizeof(MBRecState));
96 146
102 } 152 }
103 } 153 }
104 } 154 }
105 } 155 }
106 156
107 #pragma omp task input(*d, *sbe, *ml, *mur) inout(*m) 157 typedef struct{
108 static void decode_super_mb_task(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, SuperMBTask *ml, 158 MBRecContext *d;
109 SuperMBTask *mur, SuperMBTask *m){ 159 SliceBufferEntry *sbe;
160 SuperMBTask *ml;
161 SuperMBTask *mur;
162 SuperMBTask *m;
163 SuperMBContext *smbc;
164 } decode_super_mb_taskArgs;
165
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)};
168
169 //#pragma omp task input(*d, *sbe, *ml, *mur) inout(*m)
170 static void decode_super_mb_task(void *_data, SlaveVP *animatingSlv){
171 decode_super_mb_taskArgs* args = (decode_super_mb_taskArgs*) _data;
172 MBRecContext *d = args->d;
173 SliceBufferEntry *sbe = args->sbe;
174 SuperMBTask *ml = args->ml;
175 SuperMBTask *mur = args->mur;
176 SuperMBTask *m = args->m;
177 SuperMBContext *smbc = args->smbc;
110 H264Slice *s = &sbe->slice; 178 H264Slice *s = &sbe->slice;
111 H264Mb *mbs = sbe->mbs; 179 H264Mb *mbs = sbe->mbs;
112 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);
113 } 181 VSs__end_task( animatingSlv );
114 182 }
115 #pragma omp task input(*d, *sbe) inout(*sm) 183
116 static void draw_edges_task(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, SuperMBTask *sm, int line){ 184 VSsTaskType decode_super_mb_taskType = {
185 .fn = &decode_super_mb_task,
186 .numCtldArgs = 5,
187 .numTotalArgs = 6,
188 .sizeOfArgs = sizeof(decode_super_mb_taskArgs),
189 .argTypes = decode_super_mb_taskArgTypes,
190 .argSizes = decode_super_mb_taskArgSizes};
191
192
193
194 typedef struct{
195 MBRecContext *d;
196 SliceBufferEntry *sbe;
197 SuperMBTask *sm;
198 SuperMBContext *smbc;
199 int* line;
200 } draw_edges_taskArgs;
201
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)};
204
205 //#pragma omp task input(*d, *sbe) inout(*sm)
206 static void draw_edges_task(void *_data, SlaveVP *animatingSlv){
207 draw_edges_taskArgs* args = (draw_edges_taskArgs*) _data;
208 MBRecContext *d = args->d;
209 SliceBufferEntry *sbe = args->sbe;
210 SuperMBTask *sm = args->sm;
211 SuperMBContext *smbc = args->smbc;
212 int line = *(args->line);
117 H264Slice *s = &sbe->slice; 213 H264Slice *s = &sbe->slice;
118 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++)
119 draw_edges(d, s, i); 215 draw_edges(d, s, i);
120 } 216 VSs__end_task( animatingSlv );
121 217 }
122 static void decode_mb_in_slice(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe){ 218 VSsTaskType draw_edges_taskType = {
219 .fn = &draw_edges_task,
220 .numCtldArgs = 3,
221 .numTotalArgs = 5,
222 .sizeOfArgs = sizeof(draw_edges_taskArgs),
223 .argTypes = draw_edges_taskArgTypes,
224 .argSizes = draw_edges_taskArgSizes};
225
226
227 static void decode_mb_in_slice(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe, SlaveVP* animSlv){
123 int i,j; 228 int i,j;
124 229
125 SuperMBContext *smbc = acquire_smbc(h); 230 SuperMBContext *smbc = acquire_smbc(h);
126 int smb_height =smbc->nsmb_height, smb_width= smbc->nsmb_width; 231 int smb_height =smbc->nsmb_height, smb_width= smbc->nsmb_width;
127 SuperMBTask *smbs = smbc->smbs[0]; 232 SuperMBTask *smbs = smbc->smbs[0];
130 for(j=0; j< smb_height; j++){ 235 for(j=0; j< smb_height; j++){
131 for(i=0; i< smb_width; i++){ 236 for(i=0; i< smb_width; i++){
132 sm = smbs + j*smb_width + i; 237 sm = smbs + j*smb_width + i;
133 sml = sm - ((i > 0) ? 1: 0); 238 sml = sm - ((i > 0) ? 1: 0);
134 smur = sm + (((i < smb_width-1) && (j >0)) ? -smb_width+1: 0); 239 smur = sm + (((i < smb_width-1) && (j >0)) ? -smb_width+1: 0);
135 decode_super_mb_task(d, sbe, smbc, sml, smur, sm); 240 decode_super_mb_taskArgs decode_super_mb_task_args;
136 } 241 decode_super_mb_task_args.d = d;
137 draw_edges_task(d, sbe, smbc, sm, j); 242 decode_super_mb_task_args.sbe = sbe;
138 } 243 decode_super_mb_task_args.smbc = smbc;
139 #pragma omp taskwait on(*sm) 244 decode_super_mb_task_args.ml = sml;
245 decode_super_mb_task_args.mur = smur;
246 decode_super_mb_task_args.m = sm;
247 VSs__submit_task(&decode_super_mb_taskType, &decode_super_mb_task_args, animSlv);
248 }
249 draw_edges_taskArgs draw_edges_task_args;
250 draw_edges_task_args.d = d;
251 draw_edges_task_args.sbe = sbe;
252 draw_edges_task_args.sm = sm;
253 draw_edges_task_args.smbc = smbc;
254 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) );
255 *(draw_edges_task_args.line) = j;
256 VSs__submit_task(&draw_edges_taskType, &draw_edges_task_args, animSlv);
257 }
258 VSs__taskwait_on(animSlv,sm);
259 //#pragma omp taskwait on(*sm)
140 260
141 release_smbc(h, smbc); 261 release_smbc(h, smbc);
142 } 262 }
143 263
144 #pragma omp task inout(*d) inout(*sbe) 264 typedef struct{
145 static void decode_slice_mb_task(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe){ 265 MBRecContext *d;
266 SliceBufferEntry *sbe;
267 H264Context *h;
268 } decode_slice_mb_taskArgs;
269
270 int32 decode_slice_mb_taskArgTypes[3] = {INOUT, INOUT, NONCTLD};
271 int32 decode_slice_mb_taskArgSizes[3] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(H264Context)};
272
273 //#pragma omp task inout(*d) inout(*sbe)
274 static void decode_slice_mb_task(void *_data, SlaveVP *animatingSlv){
275 decode_slice_mb_taskArgs* args = (decode_slice_mb_taskArgs*) _data;
276 MBRecContext *d = args->d;
277 SliceBufferEntry *sbe = args->sbe;
278 H264Context *h = args->h;
279
146 H264Slice *s = &sbe->slice; 280 H264Slice *s = &sbe->slice;
147 281
148 for (int i=0; i<2; i++){ 282 for (int i=0; i<2; i++){
149 for(int j=0; j< s->ref_count[i]; j++){ 283 for(int j=0; j< s->ref_count[i]; j++){
150 if (s->ref_list_cpn[i][j] ==-1) 284 if (s->ref_list_cpn[i][j] ==-1)
157 } 291 }
158 } 292 }
159 } 293 }
160 } 294 }
161 295
162 #pragma omp critical (dpb) 296 //#pragma omp critical (dpb)
297 VSs__start_critical(animatingSlv,0);
163 get_dpb_entry(h, s); 298 get_dpb_entry(h, s);
164 299 VSs__end_critical(animatingSlv,0);
300
165 if (!h->no_mbd){ 301 if (!h->no_mbd){
166 decode_mb_in_slice (h, d, sbe); 302 decode_mb_in_slice (h, d, sbe, animatingSlv);
167 } 303 }
168 304
169 for (int i=0; i<s->release_cnt; i++){ 305 for (int i=0; i<s->release_cnt; i++){
170 for(int j=0; j<h->max_dpb_cnt; j++){ 306 for(int j=0; j<h->max_dpb_cnt; j++){
171 if(h->dpb[j].cpn== s->release_ref_cpn[i]){ 307 if(h->dpb[j].cpn== s->release_ref_cpn[i]){
172 #pragma omp critical (dpb) 308 //#pragma omp critical (dpb)
309 VSs__start_critical(animatingSlv,0);
173 release_dpb_entry(h, &h->dpb[j], 2); 310 release_dpb_entry(h, &h->dpb[j], 2);
311 VSs__end_critical(animatingSlv,0);
174 break; 312 break;
175 } 313 }
176 } 314 }
177 } 315 }
178 s->release_cnt=0; 316 s->release_cnt=0;
179 } 317 VSs__end_task( animatingSlv );
318 }
319
320 VSsTaskType decode_slice_mb_taskType = {
321 .fn = &decode_slice_mb_task,
322 .numCtldArgs = 2,
323 .numTotalArgs = 3,
324 .sizeOfArgs = sizeof(decode_slice_mb_taskArgs),
325 .argTypes = decode_slice_mb_taskArgTypes,
326 .argSizes = decode_slice_mb_taskArgSizes};
180 327
181 // for static 3d wave 328 // for static 3d wave
182 /*-------------------------------------------------------------------------------*/ 329 /*-------------------------------------------------------------------------------*/
183 #pragma omp task input(*d, *sbe, *ml, *mur, *mprev) inout(*m) 330 typedef struct{
184 static void decode_3dwave_super_mb_task(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, SuperMBTask *ml, 331 MBRecContext *d;
185 SuperMBTask *mur, SuperMBTask *mprev, SuperMBTask *m){ 332 SliceBufferEntry *sbe;
333 SuperMBTask *ml;
334 SuperMBTask *mur;
335 SuperMBTask *mprev;
336 SuperMBTask *m;
337 SuperMBContext *smbc;
338 } decode_3dwave_super_mb_taskArgs;
339
340 int32 decode_3dwave_super_mb_taskArgTypes[7] = {IN, IN, IN, IN, IN, INOUT, NONCTLD};
341 int32 decode_3dwave_super_mb_taskArgSizes[7] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask),
342 sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBContext)};
343
344 //#pragma omp task input(*d, *sbe, *ml, *mur, *mprev) inout(*m)
345 static void decode_3dwave_super_mb_task(void *_data, SlaveVP *animatingSlv){
346 decode_3dwave_super_mb_taskArgs* args = (decode_3dwave_super_mb_taskArgs*) _data;
347 MBRecContext *d = args->d;
348 SliceBufferEntry *sbe = args->sbe;
349 SuperMBTask *ml = args->ml;
350 SuperMBTask *mur = args->mur;
351 SuperMBTask *mprev = args->mprev;
352 SuperMBTask *m = args->m;
353 SuperMBContext *smbc = args->smbc;
354
186 H264Slice *s = &sbe->slice; 355 H264Slice *s = &sbe->slice;
187 H264Mb *mbs = sbe->mbs; 356 H264Mb *mbs = sbe->mbs;
188 357
189 decode_super_mb_block(d, s, smbc, mbs, m->smb_x, m->smb_y); 358 decode_super_mb_block(d, s, smbc, mbs, m->smb_x, m->smb_y);
190 } 359 VSs__end_task( animatingSlv );
360 }
361
362 VSsTaskType decode_3dwave_super_mb_taskType = {
363 .fn = &decode_3dwave_super_mb_task,
364 .numCtldArgs = 6,
365 .numTotalArgs = 7,
366 .sizeOfArgs = sizeof(decode_3dwave_super_mb_taskArgs),
367 .argTypes = decode_3dwave_super_mb_taskArgTypes,
368 .argSizes = decode_3dwave_super_mb_taskArgSizes};
191 369
192 // int init_ref_count=0; 370 // int init_ref_count=0;
193 #pragma omp task inout(*d, *sbe, *init) 371 typedef struct{
194 static void init_ref_list_and_get_dpb_task(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe, int *init){ 372 MBRecContext *d;
373 SliceBufferEntry *sbe;
374 int* init;
375 H264Context *h;
376 } init_ref_list_and_get_dpb_taskArgs;
377
378 int32 init_ref_list_and_get_dpb_taskArgTypes[4] = {INOUT, INOUT, INOUT, NONCTLD};
379 int32 init_ref_list_and_get_dpb_taskArgSizes[4] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(int), sizeof(H264Context)};
380
381 //#pragma omp task inout(*d, *sbe, *init)
382 static void init_ref_list_and_get_dpb_task(void *_data, SlaveVP *animatingSlv){
383 init_ref_list_and_get_dpb_taskArgs* args = (init_ref_list_and_get_dpb_taskArgs*) _data;
384 MBRecContext *d = args->d;
385 SliceBufferEntry *sbe = args->sbe;
386 int* initp = args->init;
387 H264Context *h = args->h;
388
195 H264Slice *s = &sbe->slice; 389 H264Slice *s = &sbe->slice;
196 for (int i=0; i<2; i++){ 390 for (int i=0; i<2; i++){
197 for(int j=0; j< s->ref_count[i]; j++){ 391 for(int j=0; j< s->ref_count[i]; j++){
198 if (s->ref_list_cpn[i][j] ==-1) 392 if (s->ref_list_cpn[i][j] ==-1)
199 continue; 393 continue;
205 } 399 }
206 } 400 }
207 } 401 }
208 } 402 }
209 403
210 #pragma omp critical (dpb) 404 //#pragma omp critical (dpb)
405 VSs__start_critical(animatingSlv,0);
211 get_dpb_entry(h, s); 406 get_dpb_entry(h, s);
212 407 VSs__end_critical(animatingSlv,0);
213 } 408
214 409 VSs__end_task( animatingSlv );
215 static SuperMBTask* add_decode_slice_3dwave_tasks(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc){ 410 }
411
412 VSsTaskType init_ref_list_and_get_dpb_taskType = {
413 .fn = &init_ref_list_and_get_dpb_task,
414 .numCtldArgs = 3,
415 .numTotalArgs = 4,
416 .sizeOfArgs = sizeof(init_ref_list_and_get_dpb_taskArgs),
417 .argTypes = init_ref_list_and_get_dpb_taskArgTypes,
418 .argSizes = init_ref_list_and_get_dpb_taskArgSizes};
419
420 static SuperMBTask* add_decode_slice_3dwave_tasks(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, SlaveVP* animSlv){
216 int i,j; 421 int i,j;
217 422
218 int smb_3d_height =smbc->nsmb_3dheight; 423 int smb_3d_height =smbc->nsmb_3dheight;
219 int smb_height =smbc->nsmb_height, smb_width= smbc->nsmb_width; 424 int smb_height =smbc->nsmb_height, smb_width= smbc->nsmb_width;
220 int smb_diff_prev = smb_height - smb_3d_height; 425 int smb_diff_prev = smb_height - smb_3d_height;
227 for(i=0; i< smb_width; i++){ 432 for(i=0; i< smb_width; i++){
228 sm = smbs + j*smb_width + i; 433 sm = smbs + j*smb_width + i;
229 sml = sm - ((i > 0) ? 1: 0); 434 sml = sm - ((i > 0) ? 1: 0);
230 smur = sm + (((i < smb_width-1) && (j >0)) ? -smb_width+1: 0); 435 smur = sm + (((i < smb_width-1) && (j >0)) ? -smb_width+1: 0);
231 smprev = smbs_prev + (j + smb_diff_prev+1)*smb_width -1; 436 smprev = smbs_prev + (j + smb_diff_prev+1)*smb_width -1;
232 decode_3dwave_super_mb_task(d, sbe, smbc, sml, smur, smprev, sm); 437 decode_3dwave_super_mb_taskArgs decode_3dwave_super_mb_task_args;
233 } 438 decode_3dwave_super_mb_task_args.d = d;
234 draw_edges_task(d, sbe, smbc, sm, j); 439 decode_3dwave_super_mb_task_args.sbe = sbe;
440 decode_3dwave_super_mb_task_args.smbc = smbc;
441 decode_3dwave_super_mb_task_args.ml = sml;
442 decode_3dwave_super_mb_task_args.mur = smur;
443 decode_3dwave_super_mb_task_args.mprev = smprev;
444 decode_3dwave_super_mb_task_args.m = sm;
445 VSs__submit_task(&decode_3dwave_super_mb_taskType, &decode_3dwave_super_mb_task_args, animSlv);
446 }
447 draw_edges_taskArgs draw_edges_task_args;
448 draw_edges_task_args.d = d;
449 draw_edges_task_args.sbe = sbe;
450 draw_edges_task_args.sm = sm;
451 draw_edges_task_args.smbc = smbc;
452 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) );
453 *(draw_edges_task_args.line) = j;
454 VSs__submit_task(&draw_edges_taskType, &draw_edges_task_args, animSlv);
235 } 455 }
236 456
237 for(; j< smb_height; j++){ 457 for(; j< smb_height; j++){
238 for(i=0; i< smb_width; i++){ 458 for(i=0; i< smb_width; i++){
239 sm = smbs + j*smb_width + i; 459 sm = smbs + j*smb_width + i;
240 sml = sm - ((i > 0) ? 1: 0); 460 sml = sm - ((i > 0) ? 1: 0);
241 smur = sm + (((i < smb_width-1) && (j >0)) ? -smb_width+1: 0); 461 smur = sm + (((i < smb_width-1) && (j >0)) ? -smb_width+1: 0);
242 decode_super_mb_task(d, sbe, smbc, sml, smur, sm); 462 decode_super_mb_taskArgs decode_super_mb_task_args;
243 } 463 decode_super_mb_task_args.d = d;
244 draw_edges_task(d, sbe, smbc, sm, j); 464 decode_super_mb_task_args.sbe = sbe;
465 decode_super_mb_task_args.smbc = smbc;
466 decode_super_mb_task_args.ml = sml;
467 decode_super_mb_task_args.mur = smur;
468 decode_super_mb_task_args.m = sm;
469 VSs__submit_task(&decode_super_mb_taskType, &decode_super_mb_task_args, animSlv);
470 }
471 draw_edges_taskArgs draw_edges_task_args;
472 draw_edges_task_args.d = d;
473 draw_edges_task_args.sbe = sbe;
474 draw_edges_task_args.sm = sm;
475 draw_edges_task_args.smbc = smbc;
476 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) );
477 *(draw_edges_task_args.line) = j;
478 VSs__submit_task(&draw_edges_taskType, &draw_edges_task_args, animSlv);
245 } 479 }
246 return sm; 480 return sm;
247 } 481 }
248 482
249 #pragma omp task inout(*d, *sbe, *release) input (*lastsmb) 483 typedef struct{
250 static void release_ref_list_task(H264Context *h, SuperMBContext *smbc, MBRecContext *d, SliceBufferEntry *sbe, SuperMBTask *lastsmb, int *release){ 484 MBRecContext *d;
485 SliceBufferEntry *sbe;
486 SuperMBTask *lastsmb;
487 int* release;
488 H264Context *h;
489 SuperMBContext *smbc;
490 } release_ref_list_taskArgs;
491
492 int32 release_ref_list_taskArgTypes[6] = {INOUT, INOUT, IN, INOUT, NONCTLD, NONCTLD};
493 int32 release_ref_list_taskArgSizes[6] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(int), sizeof(H264Context), sizeof(SuperMBContext)};
494
495 //#pragma omp task inout(*d, *sbe, *release) input (*lastsmb)
496 static void release_ref_list_task(void *_data, SlaveVP *animatingSlv){
497 release_ref_list_taskArgs* args = (release_ref_list_taskArgs*) _data;
498 MBRecContext *d = args->d;
499 SliceBufferEntry *sbe = args->sbe;
500 SuperMBTask *lastsmb = args->lastsmb;
501 int* releasep = args->release;
502 H264Context *h = args->h;
503 SuperMBContext *smbc = args->smbc;
504
251 H264Slice *s = &sbe->slice; 505 H264Slice *s = &sbe->slice;
252 for (int i=0; i<s->release_cnt; i++){ 506 for (int i=0; i<s->release_cnt; i++){
253 for(int j=0; j<h->max_dpb_cnt; j++){ 507 for(int j=0; j<h->max_dpb_cnt; j++){
254 if(h->dpb[j].cpn== s->release_ref_cpn[i]){ 508 if(h->dpb[j].cpn== s->release_ref_cpn[i]){
255 #pragma omp critical (dpb) 509 //#pragma omp critical (dpb)
510 VSs__start_critical(animatingSlv,0);
256 release_dpb_entry(h, &h->dpb[j], 2); 511 release_dpb_entry(h, &h->dpb[j], 2);
512 VSs__end_critical(animatingSlv,0);
257 break; 513 break;
258 } 514 }
259 } 515 }
260 } 516 }
261 s->release_cnt=0; 517 s->release_cnt=0;
262 518
263 release_smbc(h, smbc); 519 release_smbc(h, smbc);
264 520
265 } 521 VSs__end_task( animatingSlv );
522 }
523
524 VSsTaskType release_ref_list_taskType = {
525 .fn = &release_ref_list_task,
526 .numCtldArgs = 4,
527 .numTotalArgs = 6,
528 .sizeOfArgs = sizeof(release_ref_list_taskArgs),
529 .argTypes = release_ref_list_taskArgTypes,
530 .argSizes = release_ref_list_taskArgSizes};
266 531
267 // 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){ 532 // 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){
268 // 533 //
269 // } 534 // }
270 /*-------------------------------------------------------------------------------*/ 535 /*-------------------------------------------------------------------------------*/
271 //end for static 3d wave 536 //end for static 3d wave
272 537
273 #pragma omp task inout (*oc) input(*sbe) 538 typedef struct{
274 static void output_task(H264Context *h, OutputContext *oc, SliceBufferEntry *sbe){ 539 OutputContext *oc;
540 SliceBufferEntry *sbe;
541 H264Context *h;
542 } output_taskArgs;
543
544 int32 output_taskArgTypes[3] = {INOUT, IN, NONCTLD};
545 int32 output_taskArgSizes[3] = {sizeof(OutputContext), sizeof(SliceBufferEntry), sizeof(H264Context)};
546
547 //#pragma omp task inout (*oc) input(*sbe)
548 static void output_task(void *_data, SlaveVP *animatingSlv){
549 output_taskArgs* args = (output_taskArgs*) _data;
550 OutputContext *oc = args->oc;
551 SliceBufferEntry *sbe = args->sbe;
552 H264Context *h = args->h;
553
275 DecodedPicture* out =output_frame(h, oc, sbe->slice.curr_pic, h->ofile, h->frame_width, h->frame_height); 554 DecodedPicture* out =output_frame(h, oc, sbe->slice.curr_pic, h->ofile, h->frame_width, h->frame_height);
276 if (out){ 555 if (out){
277 #pragma omp critical (dpb) 556 //#pragma omp critical (dpb)
557 VSs__start_critical(animatingSlv,0);
278 release_dpb_entry(h, out, 1); 558 release_dpb_entry(h, out, 1);
559 VSs__end_critical(animatingSlv,0);
279 } 560 }
280 print_report(oc->frame_number, oc->video_size, 0, h->verbose); 561 print_report(oc->frame_number, oc->video_size, 0, h->verbose);
281 } 562
563 VSs__end_task( animatingSlv );
564 }
565
566 VSsTaskType output_taskType = {
567 .fn = &output_task,
568 .numCtldArgs = 2,
569 .numTotalArgs = 3,
570 .sizeOfArgs = sizeof(output_taskArgs),
571 .argTypes = output_taskArgTypes,
572 .argSizes = output_taskArgSizes};
282 573
283 /* 574 /*
284 * The following code is the main loop of the file converter 575 * The following code is the main loop of the file converter
285 */ 576 */
286 //Put VMS entry point here 577 //Put VMS entry point here
287 int h264_decode_ompss( H264Context *h) { 578
579 void h264_decode_ompss( void *_params, SlaveVP *animSlv) {
580 H264Context* h = (H264Context*) _params;
581
288 const int bufs = h->pipe_bufs; 582 const int bufs = h->pipe_bufs;
289 583
290 ParserContext *pc; 584 ParserContext *pc;
291 NalContext *nc; 585 NalContext *nc;
292 EntropyContext *ec[bufs]; 586 EntropyContext *ec[bufs];
302 pthread_t sdl_thr; 596 pthread_t sdl_thr;
303 if (h->display){ 597 if (h->display){
304 pthread_create(&sdl_thr, NULL, sdl_thread, h); 598 pthread_create(&sdl_thr, NULL, sdl_thread, h);
305 } 599 }
306 #endif 600 #endif
601 /*sbe= VMS_WL__malloc(sizeof(SliceBufferEntry) * bufs);
602 if (sbe)
603 memset(sbe, 0, sizeof(SliceBufferEntry) * bufs);*/
307 sbe= av_mallocz(sizeof(SliceBufferEntry) * bufs); 604 sbe= av_mallocz(sizeof(SliceBufferEntry) * bufs);
308
309 605
310 pc = get_parse_context(h->ifile); 606 pc = get_parse_context(h->ifile);
311 nc = get_nal_context(h->width, h->height); 607 nc = get_nal_context(h->width, h->height);
312 608
313 for(int i=0; i<bufs; i++){ 609 for(int i=0; i<bufs; i++){
323 av_start_timer(); 619 av_start_timer();
324 int k=0; int init, release; 620 int k=0; int init, release;
325 if (h->static_3d && bufs < h->num_frames ){ 621 if (h->static_3d && bufs < h->num_frames ){
326 int num_pre_ed =0; 622 int num_pre_ed =0;
327 for (num_pre_ed=0; num_pre_ed< bufs -1 && !pc->final_frame; num_pre_ed++){ 623 for (num_pre_ed=0; num_pre_ed< bufs -1 && !pc->final_frame; num_pre_ed++){
328 parse_task( h, pc, nc, &sbe[k%bufs] ); 624 parse_taskArgs parse_task_args;
329 decode_slice_entropy_task(h, ec[k%bufs], &sbe[k%bufs]); 625 parse_task_args.h = h;
330 #pragma omp taskwait on(*pc) 626 parse_task_args.pc = pc;
627 parse_task_args.nc = nc;
628 parse_task_args.sbe = &sbe[k%bufs];
629 VSs__submit_task(&parse_taskType, &parse_task_args, animSlv);
630
631 decode_slice_entropy_taskArgs decode_slice_entropy_task_args;
632 decode_slice_entropy_task_args.h = h;
633 decode_slice_entropy_task_args.ec = ec[k%bufs];
634 decode_slice_entropy_task_args.sbe = &sbe[k%bufs];
635 VSs__submit_task(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, animSlv);
636 //#pragma omp taskwait on(*pc)
637 VSs__taskwait_on(animSlv,pc);
331 k++; 638 k++;
332 } 639 }
333 640
334 while(!pc->final_frame && frames++ < h->num_frames && !h->quit){ 641 while(!pc->final_frame && frames++ < h->num_frames && !h->quit){
335 parse_task( h, pc, nc, &sbe[k%bufs] ); 642 parse_taskArgs parse_task_args;
336 decode_slice_entropy_task(h, ec[k%bufs], &sbe[k%bufs]); 643 parse_task_args.h = h;
644 parse_task_args.pc = pc;
645 parse_task_args.nc = nc;
646 parse_task_args.sbe = &sbe[k%bufs];
647 VSs__submit_task(&parse_taskType, &parse_task_args, animSlv);
648
649 decode_slice_entropy_taskArgs decode_slice_entropy_task_args;
650 decode_slice_entropy_task_args.h = h;
651 decode_slice_entropy_task_args.ec = ec[k%bufs];
652 decode_slice_entropy_task_args.sbe = &sbe[k%bufs];
653 VSs__submit_task(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, animSlv);
337 654
338 k++; 655 k++;
339 656
340 init_ref_list_and_get_dpb_task(h, rc[k%2], &sbe[k%bufs], &init); 657 init_ref_list_and_get_dpb_taskArgs init_ref_list_and_get_dpb_task_args;
658 init_ref_list_and_get_dpb_task_args.h = h;
659 init_ref_list_and_get_dpb_task_args.d = rc[k%2];
660 init_ref_list_and_get_dpb_task_args.sbe = &sbe[k%bufs];
661 init_ref_list_and_get_dpb_task_args.init = &init;
662 VSs__submit_task(&init_ref_list_and_get_dpb_taskType, &init_ref_list_and_get_dpb_task_args, animSlv);
663
341 smbc = acquire_smbc(h); 664 smbc = acquire_smbc(h);
342 SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc); 665 SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc, animSlv);
343 release_ref_list_task(h, smbc, rc[k%2], &sbe[k%bufs], lastsmb, &release); 666 release_ref_list_taskArgs release_ref_list_task_args;
344 667 release_ref_list_task_args.h = h;
345 output_task (h, oc, &sbe[k%bufs]); 668 release_ref_list_task_args.smbc = smbc;
346 #pragma omp taskwait on(*pc) 669 release_ref_list_task_args.d = rc[k%2];
670 release_ref_list_task_args.sbe = &sbe[k%bufs];
671 release_ref_list_task_args.lastsmb = lastsmb;
672 release_ref_list_task_args.release = &release;
673 VSs__submit_task(&release_ref_list_taskType, &release_ref_list_task_args, animSlv);
674
675 output_taskArgs output_task_args;
676 output_task_args.h = h;
677 output_task_args.oc = oc;
678 output_task_args.sbe = &sbe[k%bufs];
679 VSs__submit_task(&output_taskType, &output_task_args, animSlv);
680 //#pragma omp taskwait on(*pc)
681 VSs__taskwait_on(animSlv,pc);
347 } 682 }
348 683
349 for (int i=0; i< num_pre_ed; i++){ 684 for (int i=0; i< num_pre_ed; i++){
350 k++; 685 k++;
351 init_ref_list_and_get_dpb_task(h, rc[k%2], &sbe[k%bufs], &init); 686 init_ref_list_and_get_dpb_taskArgs init_ref_list_and_get_dpb_task_args;
687 init_ref_list_and_get_dpb_task_args.h = h;
688 init_ref_list_and_get_dpb_task_args.d = rc[k%2];
689 init_ref_list_and_get_dpb_task_args.sbe = &sbe[k%bufs];
690 init_ref_list_and_get_dpb_task_args.init = &init;
691 VSs__submit_task(&init_ref_list_and_get_dpb_taskType, &init_ref_list_and_get_dpb_task_args, animSlv);
352 smbc = acquire_smbc(h); 692 smbc = acquire_smbc(h);
353 SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc); 693 SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc, animSlv);
354 release_ref_list_task(h, smbc, rc[k%2], &sbe[k%bufs], lastsmb, &release); 694 release_ref_list_taskArgs release_ref_list_task_args;
355 695 release_ref_list_task_args.h = h;
356 output_task (h, oc, &sbe[k%bufs]); 696 release_ref_list_task_args.smbc = smbc;
697 release_ref_list_task_args.d = rc[k%2];
698 release_ref_list_task_args.sbe = &sbe[k%bufs];
699 release_ref_list_task_args.lastsmb = lastsmb;
700 release_ref_list_task_args.release = &release;
701 VSs__submit_task(&release_ref_list_taskType, &release_ref_list_task_args, animSlv);
702
703 output_taskArgs output_task_args;
704 output_task_args.h = h;
705 output_task_args.oc = oc;
706 output_task_args.sbe = &sbe[k%bufs];
707 VSs__submit_task(&output_taskType, &output_task_args, animSlv);
357 } 708 }
358 709
359 } else { 710 } else {
360 while(!pc->final_frame && frames++ < h->num_frames && !h->quit){ 711 while(!pc->final_frame && frames++ < h->num_frames && !h->quit){
361 parse_task( h, pc, nc, &sbe[k%bufs] ); 712 int32* taskID;
362 713 taskID = VSs__create_taskID_of_size(1,animSlv );
363 decode_slice_entropy_task(h, ec[k%bufs], &sbe[k%bufs]); 714 taskID[1] = frames*10+1;
364 715 parse_taskArgs parse_task_args;
365 decode_slice_mb_task(h, rc[0], &sbe[k%bufs]); 716 parse_task_args.h = h;
366 717 parse_task_args.pc = pc;
367 output_task (h, oc, &sbe[k%bufs]); 718 parse_task_args.nc = nc;
368 #pragma omp taskwait on(*pc) 719 parse_task_args.sbe = &sbe[k%bufs];
720 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, taskID, animSlv);
721
722 taskID = VSs__create_taskID_of_size(1,animSlv );
723 taskID[1] = frames*10+2;
724 decode_slice_entropy_taskArgs decode_slice_entropy_task_args;
725 decode_slice_entropy_task_args.h = h;
726 decode_slice_entropy_task_args.ec = ec[k%bufs];
727 decode_slice_entropy_task_args.sbe = &sbe[k%bufs];
728 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args,taskID, animSlv);
729
730 taskID = VSs__create_taskID_of_size(1,animSlv );
731 taskID[1] = frames*10+3;
732 decode_slice_mb_taskArgs decode_slice_mb_task_args;
733 decode_slice_mb_task_args.h = h;
734 decode_slice_mb_task_args.d = rc[0];
735 decode_slice_mb_task_args.sbe = &sbe[k%bufs];
736 VSs__submit_task_with_ID(&decode_slice_mb_taskType, &decode_slice_mb_task_args,taskID, animSlv);
737
738 taskID = VSs__create_taskID_of_size(1,animSlv );
739 taskID[1] = frames*10+4;
740 output_taskArgs output_task_args;
741 output_task_args.h = h;
742 output_task_args.oc = oc;
743 output_task_args.sbe = &sbe[k%bufs];
744 VSs__submit_task_with_ID(&output_taskType, &output_task_args,taskID, animSlv);
745 //#pragma omp taskwait on(*pc)
746 VSs__taskwait_on(animSlv,pc);
369 k++; 747 k++;
370 } 748 }
371 } 749 }
372 #pragma omp taskwait 750 //#pragma omp taskwait
373 751 VSs__taskwait(animSlv);
752
374 while ((out=output_frame(h, oc, NULL, h->ofile, h->frame_width, h->frame_height))) ; 753 while ((out=output_frame(h, oc, NULL, h->ofile, h->frame_width, h->frame_height))) ;
375 754
376 print_report(oc->frame_number, oc->video_size, 1, h->verbose); 755 print_report(oc->frame_number, oc->video_size, 1, h->verbose);
377 h->num_frames = oc->frame_number; 756 h->num_frames = oc->frame_number;
378 /* finished ! */ 757 /* finished ! */
395 signal_sdl_exit(h); 774 signal_sdl_exit(h);
396 pthread_join(sdl_thr, NULL); 775 pthread_join(sdl_thr, NULL);
397 } 776 }
398 #endif 777 #endif
399 778
400 return 0; 779 VSs__end_thread( animSlv );
401 } 780 }