# HG changeset patch
# User Nina Engelhardt <nengel@mailbox.tu-berlin.de>
# Date 1351525467 -3600
# Node ID 0b056460c67de39a266072cd72e3fa671ca2b08b
# Parent  897f711a7157c133b3bbdd2d9bb2e924baa9de8b
changed code to use VSs

diff -r 897f711a7157 -r 0b056460c67d h264dec.c
--- a/h264dec.c	Tue Sep 25 15:55:33 2012 +0200
+++ b/h264dec.c	Mon Oct 29 16:44:27 2012 +0100
@@ -20,6 +20,7 @@
 
 #include <assert.h>
 
+#include "VSs_impl/VSs.h"
 
 static const char program_name[] = "h264dec";
 static const int program_birth_year = 2010;
@@ -259,8 +260,7 @@
 
     H264Context *h = get_h264dec_context(file_name, ifile, ofile, frame_width, frame_height, &cli_opts);
 #if OMPSS
-    if (h264_decode_ompss( h ) < 0)
-        av_exit(-1);
+    VSs__create_seed_slave_and_do_work( &h264_decode_ompss , (void*)h );
 #else
     if (parallel){
         if (ARCH_CELL && !no_arch){
diff -r 897f711a7157 -r 0b056460c67d libavcodec/h264.h
--- a/libavcodec/h264.h	Tue Sep 25 15:55:33 2012 +0200
+++ b/libavcodec/h264.h	Mon Oct 29 16:44:27 2012 +0100
@@ -39,6 +39,7 @@
 #include "h264_rec.h"
 #include "h264_deblock.h"
 #include "h264_types.h"
+#include "VSs_impl/VSs.h"
 
 typedef struct h264_options{
     int statsched;
@@ -63,7 +64,7 @@
 int h264_decode_cell(H264Context *h);
 int h264_decode_cell_seq(H264Context *h);
 
-int h264_decode_ompss(H264Context *h);
+void h264_decode_ompss(void *_params, SlaveVP *animSlv);
 
 int h264_decode_pthread(H264Context *h);
 int h264_decode_seq(H264Context *h);
diff -r 897f711a7157 -r 0b056460c67d libavcodec/h264_misc.c
--- a/libavcodec/h264_misc.c	Tue Sep 25 15:55:33 2012 +0200
+++ b/libavcodec/h264_misc.c	Mon Oct 29 16:44:27 2012 +0100
@@ -266,18 +266,18 @@
     }
 
     if (verbose){
-        fprintf(stderr, "frame=%5d avgfps=%3d curfps=%3d\r", frame_number, (int)(frame_number/t+0.5), (int)((frame_number - last_frame_number)/t2+0.5) );
-        fflush(stderr);
+        //fprintf(stderr, "frame=%5d avgfps=%3d curfps=%3d\r", frame_number, (int)(frame_number/t+0.5), (int)((frame_number - last_frame_number)/t2+0.5) );
+        //fflush(stderr);
     }
     last_frame_number = frame_number;
     last_time = cur_time;
 
     if (is_last_report){
         t = (av_gettime()-timer_start) / 1000000.0;
-        fprintf(stderr, "%c[2Kframe=%5d avgfps=%3d\r", 27, frame_number, (int)(frame_number/t+0.5));
-        fprintf(stderr, "\n");
-        fprintf(stderr, "video:%1.0fkB\n", video_size/1024.0);
-        fflush(stderr);
+        //fprintf(stderr, "%c[2Kframe=%5d avgfps=%3d\r", 27, frame_number, (int)(frame_number/t+0.5));
+        //fprintf(stderr, "\n");
+        //fprintf(stderr, "video:%1.0fkB\n", video_size/1024.0);
+        //fflush(stderr);
     }
 }
 
diff -r 897f711a7157 -r 0b056460c67d libavcodec/h264_ompss.c
--- a/libavcodec/h264_ompss.c	Tue Sep 25 15:55:33 2012 +0200
+++ b/libavcodec/h264_ompss.c	Mon Oct 29 16:44:27 2012 +0100
@@ -27,9 +27,25 @@
 #include "h264_misc.h"
 // #undef NDEBUG
 #include <assert.h>
+#include "VSs_impl/VSs.h"
 
-#pragma omp task inout(*pc, *nc) output(*sbe)
-static void parse_task(H264Context *h, ParserContext *pc, NalContext *nc, SliceBufferEntry *sbe){
+typedef struct{
+    ParserContext *pc;
+    NalContext *nc;
+    SliceBufferEntry *sbe; 
+    H264Context *h;
+} parse_taskArgs;
+
+int32 parse_taskArgTypes[4] = {INOUT, INOUT, OUTPUT, NONCTLD};
+int32 parse_taskArgSizes[4] = {sizeof(ParserContext), sizeof(NalContext), sizeof(SliceBufferEntry), sizeof(H264Context)};
+
+//#pragma omp task inout(*pc, *nc) output(*sbe)
+static void parse_task(void *_data, SlaveVP *animatingSlv){
+    parse_taskArgs* args = (parse_taskArgs*) _data;
+    ParserContext *pc = args->pc;
+    NalContext *nc = args->nc;
+    SliceBufferEntry *sbe = args->sbe; 
+    H264Context *h = args->h;
     H264Slice *s;
 
     if (!sbe->initialized){
@@ -41,10 +57,34 @@
     s = &sbe->slice;
 
     decode_nal_units(nc, s, &sbe->gb);
+    
+    VSs__end_task( animatingSlv );
 }
 
-#pragma omp task inout(*ec) inout(*sbe)
-static void decode_slice_entropy_task(H264Context *h, EntropyContext *ec, SliceBufferEntry *sbe){
+VSsTaskType parse_taskType = {
+    .fn = &parse_task,
+    .numCtldArgs = 3,
+    .numTotalArgs = 4,
+    .sizeOfArgs = sizeof(parse_taskArgs),
+    .argTypes = parse_taskArgTypes,
+    .argSizes = parse_taskArgSizes};
+
+
+typedef struct{
+    EntropyContext *ec; 
+    SliceBufferEntry *sbe; 
+    H264Context *h;
+} decode_slice_entropy_taskArgs;
+
+int32 decode_slice_entropy_taskArgTypes[3] = {INOUT, INOUT, NONCTLD};
+int32 decode_slice_entropy_taskArgSizes[3] = {sizeof(EntropyContext), sizeof(SliceBufferEntry), sizeof(H264Context)};
+
+//#pragma omp task inout(*ec) inout(*sbe)
+static void decode_slice_entropy_task(void *_data, SlaveVP *animatingSlv){
+    decode_slice_entropy_taskArgs* args = (decode_slice_entropy_taskArgs*) _data;
+    EntropyContext *ec = args->ec; 
+    SliceBufferEntry *sbe = args->sbe; 
+    H264Context *h = args->h;
     int i,j;
     H264Slice *s = &sbe->slice;
     GetBitContext *gb = &sbe->gb;
@@ -54,7 +94,7 @@
 
     if( !s->pps.cabac ){
         av_log(AV_LOG_ERROR, "Only cabac encoded streams are supported\n");
-        return ;
+        VSs__end_task( animatingSlv );
     }
 
     init_dequant_tables(s, ec);
@@ -84,12 +124,22 @@
             (void) eos;
             if( ret < 0 || c->bytestream > c->bytestream_end + 2) {
                 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);
-                return ;
+                VSs__end_task( animatingSlv );
             }
         }
     }
+    VSs__end_task( animatingSlv );
 }
 
+VSsTaskType decode_slice_entropy_taskType = {
+    .fn = &decode_slice_entropy_task,
+    .numCtldArgs = 2,
+    .numTotalArgs = 3,
+    .sizeOfArgs = sizeof(decode_slice_entropy_taskArgs),
+    .argTypes = decode_slice_entropy_taskArgTypes,
+    .argSizes = decode_slice_entropy_taskArgSizes};
+
+
 static void decode_super_mb_block(MBRecContext *d, H264Slice *s, SuperMBContext *smbc, H264Mb *mbs, int smb_x, int smb_y){
     MBRecState mrs;
 //     memset(&mrs, 0, sizeof(MBRecState));
@@ -104,22 +154,77 @@
     }
 }
 
-#pragma omp task input(*d, *sbe, *ml, *mur) inout(*m)
-static void decode_super_mb_task(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, SuperMBTask *ml,
-SuperMBTask *mur, SuperMBTask *m){
+typedef struct{
+    MBRecContext *d;
+    SliceBufferEntry *sbe;
+    SuperMBTask *ml;
+    SuperMBTask *mur;
+    SuperMBTask *m;
+    SuperMBContext *smbc;
+} decode_super_mb_taskArgs;
+
+int32 decode_super_mb_taskArgTypes[6] = {IN, IN, IN, IN, INOUT, NONCTLD};
+int32 decode_super_mb_taskArgSizes[6] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBContext)};
+
+//#pragma omp task input(*d, *sbe, *ml, *mur) inout(*m)
+static void decode_super_mb_task(void *_data, SlaveVP *animatingSlv){
+    decode_super_mb_taskArgs* args = (decode_super_mb_taskArgs*) _data;
+    MBRecContext *d = args->d;
+    SliceBufferEntry *sbe = args->sbe;
+    SuperMBTask *ml = args->ml;
+    SuperMBTask *mur = args->mur;
+    SuperMBTask *m = args->m;
+    SuperMBContext *smbc = args->smbc;
     H264Slice *s = &sbe->slice;
     H264Mb *mbs = sbe->mbs;
     decode_super_mb_block(d, s, smbc, mbs, m->smb_x, m->smb_y);
+    VSs__end_task( animatingSlv );
 }
 
-#pragma omp task input(*d, *sbe) inout(*sm)
-static void draw_edges_task(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, SuperMBTask *sm, int line){
+VSsTaskType decode_super_mb_taskType = {
+    .fn = &decode_super_mb_task,
+    .numCtldArgs = 5,
+    .numTotalArgs = 6,
+    .sizeOfArgs = sizeof(decode_super_mb_taskArgs),
+    .argTypes = decode_super_mb_taskArgTypes,
+    .argSizes = decode_super_mb_taskArgSizes};
+
+
+
+typedef struct{
+    MBRecContext *d;
+    SliceBufferEntry *sbe;
+    SuperMBTask *sm;
+    SuperMBContext *smbc;
+    int* line;
+} draw_edges_taskArgs;
+
+int32 draw_edges_taskArgTypes[5] = {IN, IN, INOUT, NONCTLD, NONCTLD};
+int32 draw_edges_taskArgSizes[5] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask),sizeof(SuperMBContext),sizeof(int)};
+
+//#pragma omp task input(*d, *sbe) inout(*sm)
+static void draw_edges_task(void *_data, SlaveVP *animatingSlv){
+    draw_edges_taskArgs* args = (draw_edges_taskArgs*) _data;
+    MBRecContext *d = args->d;
+    SliceBufferEntry *sbe = args->sbe;
+    SuperMBTask *sm = args->sm;
+    SuperMBContext *smbc = args->smbc;
+    int line = *(args->line);
     H264Slice *s = &sbe->slice;
     for (int i=line*smbc->smb_height; i< (line+1)*smbc->smb_height && i< d->mb_height; i++)
         draw_edges(d, s, i);
+    VSs__end_task( animatingSlv );
 }
+VSsTaskType draw_edges_taskType = {
+    .fn = &draw_edges_task,
+    .numCtldArgs = 3,
+    .numTotalArgs = 5,
+    .sizeOfArgs = sizeof(draw_edges_taskArgs),
+    .argTypes = draw_edges_taskArgTypes,
+    .argSizes = draw_edges_taskArgSizes};
 
-static void decode_mb_in_slice(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe){
+
+static void decode_mb_in_slice(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe, SlaveVP* animSlv){
     int i,j;
 
     SuperMBContext *smbc = acquire_smbc(h);
@@ -132,17 +237,46 @@
             sm = smbs + j*smb_width + i;
             sml  = sm - ((i > 0) ? 1: 0);
             smur = sm + (((i < smb_width-1) && (j >0))  ? -smb_width+1: 0);
-            decode_super_mb_task(d, sbe, smbc, sml, smur, sm);
+            decode_super_mb_taskArgs decode_super_mb_task_args;
+            decode_super_mb_task_args.d = d;
+            decode_super_mb_task_args.sbe = sbe;
+            decode_super_mb_task_args.smbc = smbc;
+            decode_super_mb_task_args.ml = sml;
+            decode_super_mb_task_args.mur = smur;
+            decode_super_mb_task_args.m = sm;
+            VSs__submit_task(&decode_super_mb_taskType, &decode_super_mb_task_args, animSlv);
         }
-        draw_edges_task(d, sbe, smbc, sm, j);
+        draw_edges_taskArgs draw_edges_task_args;
+        draw_edges_task_args.d = d;
+        draw_edges_task_args.sbe = sbe;
+        draw_edges_task_args.sm = sm;
+        draw_edges_task_args.smbc = smbc;
+        draw_edges_task_args.line = VMS_App__malloc( sizeof(int) );
+        *(draw_edges_task_args.line) = j;
+        VSs__submit_task(&draw_edges_taskType, &draw_edges_task_args, animSlv);
     }
-    #pragma omp taskwait on(*sm)
+    VSs__taskwait_on(animSlv,sm);
+    //#pragma omp taskwait on(*sm)
 
     release_smbc(h, smbc);
 }
 
-#pragma omp task inout(*d) inout(*sbe)
-static void decode_slice_mb_task(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe){
+typedef struct{
+    MBRecContext *d;
+    SliceBufferEntry *sbe;
+    H264Context *h;
+} decode_slice_mb_taskArgs;
+
+int32 decode_slice_mb_taskArgTypes[3] = {INOUT, INOUT, NONCTLD};
+int32 decode_slice_mb_taskArgSizes[3] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(H264Context)};
+
+//#pragma omp task inout(*d) inout(*sbe)
+static void decode_slice_mb_task(void *_data, SlaveVP *animatingSlv){
+    decode_slice_mb_taskArgs* args = (decode_slice_mb_taskArgs*) _data;
+    MBRecContext *d = args->d;
+    SliceBufferEntry *sbe = args->sbe;
+    H264Context *h = args->h;
+    
     H264Slice *s = &sbe->slice;
 
     for (int i=0; i<2; i++){
@@ -159,39 +293,99 @@
         }
     }
 
-    #pragma omp critical (dpb)
+    //#pragma omp critical (dpb)
+    VSs__start_critical(animatingSlv,0);
     get_dpb_entry(h, s);
-
+    VSs__end_critical(animatingSlv,0);
+            
     if (!h->no_mbd){
-        decode_mb_in_slice (h, d, sbe);
+        decode_mb_in_slice (h, d, sbe, animatingSlv);
     }
 
     for (int i=0; i<s->release_cnt; i++){
         for(int j=0; j<h->max_dpb_cnt; j++){
             if(h->dpb[j].cpn== s->release_ref_cpn[i]){
-                #pragma omp critical (dpb)
+                //#pragma omp critical (dpb)
+                VSs__start_critical(animatingSlv,0);
                 release_dpb_entry(h, &h->dpb[j], 2);
+                VSs__end_critical(animatingSlv,0);
                 break;
             }
         }
     }
     s->release_cnt=0;
+    VSs__end_task( animatingSlv );
 }
 
+VSsTaskType decode_slice_mb_taskType = {
+    .fn = &decode_slice_mb_task,
+    .numCtldArgs = 2,
+    .numTotalArgs = 3,
+    .sizeOfArgs = sizeof(decode_slice_mb_taskArgs),
+    .argTypes = decode_slice_mb_taskArgTypes,
+    .argSizes = decode_slice_mb_taskArgSizes};
+
 // for static 3d wave
 /*-------------------------------------------------------------------------------*/
-#pragma omp task input(*d, *sbe, *ml, *mur, *mprev) inout(*m)
-static void decode_3dwave_super_mb_task(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, SuperMBTask *ml,
-SuperMBTask *mur, SuperMBTask *mprev, SuperMBTask *m){
+typedef struct{
+    MBRecContext *d;
+    SliceBufferEntry *sbe;
+    SuperMBTask *ml;
+    SuperMBTask *mur;
+    SuperMBTask *mprev;
+    SuperMBTask *m;
+    SuperMBContext *smbc;
+} decode_3dwave_super_mb_taskArgs;
+
+int32 decode_3dwave_super_mb_taskArgTypes[7] = {IN, IN, IN, IN, IN, INOUT, NONCTLD};
+int32 decode_3dwave_super_mb_taskArgSizes[7] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask),
+        sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBContext)};
+
+//#pragma omp task input(*d, *sbe, *ml, *mur, *mprev) inout(*m)
+static void decode_3dwave_super_mb_task(void *_data, SlaveVP *animatingSlv){
+    decode_3dwave_super_mb_taskArgs* args = (decode_3dwave_super_mb_taskArgs*) _data;
+    MBRecContext *d = args->d;
+    SliceBufferEntry *sbe = args->sbe;
+    SuperMBTask *ml = args->ml;
+    SuperMBTask *mur = args->mur;
+    SuperMBTask *mprev = args->mprev;
+    SuperMBTask *m = args->m;
+    SuperMBContext *smbc = args->smbc;
+    
     H264Slice *s = &sbe->slice;
     H264Mb *mbs = sbe->mbs;
 
     decode_super_mb_block(d, s, smbc, mbs, m->smb_x, m->smb_y);
+    VSs__end_task( animatingSlv );
 }
 
+VSsTaskType decode_3dwave_super_mb_taskType = {
+    .fn = &decode_3dwave_super_mb_task,
+    .numCtldArgs = 6,
+    .numTotalArgs = 7,
+    .sizeOfArgs = sizeof(decode_3dwave_super_mb_taskArgs),
+    .argTypes = decode_3dwave_super_mb_taskArgTypes,
+    .argSizes = decode_3dwave_super_mb_taskArgSizes};
+
 // int init_ref_count=0;
-#pragma omp task inout(*d, *sbe, *init)
-static void init_ref_list_and_get_dpb_task(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe, int *init){
+typedef struct{
+    MBRecContext *d;
+    SliceBufferEntry *sbe;
+    int* init;
+    H264Context *h;
+} init_ref_list_and_get_dpb_taskArgs;
+
+int32 init_ref_list_and_get_dpb_taskArgTypes[4] = {INOUT, INOUT, INOUT, NONCTLD};
+int32 init_ref_list_and_get_dpb_taskArgSizes[4] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(int), sizeof(H264Context)};
+
+//#pragma omp task inout(*d, *sbe, *init)
+static void init_ref_list_and_get_dpb_task(void *_data, SlaveVP *animatingSlv){
+    init_ref_list_and_get_dpb_taskArgs* args = (init_ref_list_and_get_dpb_taskArgs*) _data;
+    MBRecContext *d = args->d;
+    SliceBufferEntry *sbe = args->sbe;
+    int* initp = args->init;
+    H264Context *h = args->h;
+    
     H264Slice *s = &sbe->slice;
     for (int i=0; i<2; i++){
         for(int j=0; j< s->ref_count[i]; j++){
@@ -207,12 +401,23 @@
         }
     }
 
-    #pragma omp critical (dpb)
+    //#pragma omp critical (dpb)
+    VSs__start_critical(animatingSlv,0);
     get_dpb_entry(h, s);
-
+    VSs__end_critical(animatingSlv,0);
+    
+    VSs__end_task( animatingSlv );
 }
 
-static SuperMBTask* add_decode_slice_3dwave_tasks(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc){
+VSsTaskType init_ref_list_and_get_dpb_taskType = {
+    .fn = &init_ref_list_and_get_dpb_task,
+    .numCtldArgs = 3,
+    .numTotalArgs = 4,
+    .sizeOfArgs = sizeof(init_ref_list_and_get_dpb_taskArgs),
+    .argTypes = init_ref_list_and_get_dpb_taskArgTypes,
+    .argSizes = init_ref_list_and_get_dpb_taskArgSizes};
+
+static SuperMBTask* add_decode_slice_3dwave_tasks(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, SlaveVP* animSlv){
     int i,j;
     
     int smb_3d_height =smbc->nsmb_3dheight;
@@ -229,9 +434,24 @@
             sml  = sm - ((i > 0) ? 1: 0);
             smur = sm + (((i < smb_width-1) && (j >0))  ? -smb_width+1: 0);
             smprev = smbs_prev + (j + smb_diff_prev+1)*smb_width -1;
-            decode_3dwave_super_mb_task(d, sbe, smbc, sml, smur, smprev, sm);
+            decode_3dwave_super_mb_taskArgs decode_3dwave_super_mb_task_args;
+            decode_3dwave_super_mb_task_args.d = d;
+            decode_3dwave_super_mb_task_args.sbe = sbe;
+            decode_3dwave_super_mb_task_args.smbc = smbc;
+            decode_3dwave_super_mb_task_args.ml = sml;
+            decode_3dwave_super_mb_task_args.mur = smur;
+            decode_3dwave_super_mb_task_args.mprev = smprev;
+            decode_3dwave_super_mb_task_args.m = sm;
+            VSs__submit_task(&decode_3dwave_super_mb_taskType, &decode_3dwave_super_mb_task_args, animSlv);
         }
-        draw_edges_task(d, sbe, smbc, sm, j);
+        draw_edges_taskArgs draw_edges_task_args;
+        draw_edges_task_args.d = d;
+        draw_edges_task_args.sbe = sbe;
+        draw_edges_task_args.sm = sm;
+        draw_edges_task_args.smbc = smbc;
+        draw_edges_task_args.line = VMS_App__malloc( sizeof(int) );
+        *(draw_edges_task_args.line) = j;
+        VSs__submit_task(&draw_edges_taskType, &draw_edges_task_args, animSlv);
     }
 
     for(; j< smb_height; j++){
@@ -239,21 +459,57 @@
             sm = smbs + j*smb_width + i;
             sml  = sm - ((i > 0) ? 1: 0);
             smur = sm + (((i < smb_width-1) && (j >0))  ? -smb_width+1: 0);
-            decode_super_mb_task(d, sbe, smbc, sml, smur, sm);
+            decode_super_mb_taskArgs decode_super_mb_task_args;
+            decode_super_mb_task_args.d = d;
+            decode_super_mb_task_args.sbe = sbe;
+            decode_super_mb_task_args.smbc = smbc;
+            decode_super_mb_task_args.ml = sml;
+            decode_super_mb_task_args.mur = smur;
+            decode_super_mb_task_args.m = sm;
+            VSs__submit_task(&decode_super_mb_taskType, &decode_super_mb_task_args, animSlv);
         }
-        draw_edges_task(d, sbe, smbc, sm, j);
+        draw_edges_taskArgs draw_edges_task_args;
+        draw_edges_task_args.d = d;
+        draw_edges_task_args.sbe = sbe;
+        draw_edges_task_args.sm = sm;
+        draw_edges_task_args.smbc = smbc;
+        draw_edges_task_args.line = VMS_App__malloc( sizeof(int) );
+        *(draw_edges_task_args.line) = j;
+        VSs__submit_task(&draw_edges_taskType, &draw_edges_task_args, animSlv);
     }
     return sm;
 }
 
-#pragma omp task inout(*d, *sbe, *release) input (*lastsmb)
-static void release_ref_list_task(H264Context *h, SuperMBContext *smbc, MBRecContext *d, SliceBufferEntry *sbe, SuperMBTask *lastsmb, int *release){
+typedef struct{
+    MBRecContext *d;
+    SliceBufferEntry *sbe;
+    SuperMBTask *lastsmb;
+    int* release;
+    H264Context *h;
+    SuperMBContext *smbc;
+} release_ref_list_taskArgs;
+
+int32 release_ref_list_taskArgTypes[6] = {INOUT, INOUT, IN, INOUT, NONCTLD, NONCTLD};
+int32 release_ref_list_taskArgSizes[6] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(int), sizeof(H264Context), sizeof(SuperMBContext)};
+
+//#pragma omp task inout(*d, *sbe, *release) input (*lastsmb)
+static void release_ref_list_task(void *_data, SlaveVP *animatingSlv){
+    release_ref_list_taskArgs* args = (release_ref_list_taskArgs*) _data;
+    MBRecContext *d = args->d;
+    SliceBufferEntry *sbe = args->sbe;
+    SuperMBTask *lastsmb = args->lastsmb;
+    int* releasep = args->release;
+    H264Context *h = args->h;
+    SuperMBContext *smbc = args->smbc;
+    
     H264Slice *s = &sbe->slice;
     for (int i=0; i<s->release_cnt; i++){
         for(int j=0; j<h->max_dpb_cnt; j++){
             if(h->dpb[j].cpn== s->release_ref_cpn[i]){
-                #pragma omp critical (dpb)
+                //#pragma omp critical (dpb)
+                VSs__start_critical(animatingSlv,0);
                 release_dpb_entry(h, &h->dpb[j], 2);
+                VSs__end_critical(animatingSlv,0);
                 break;
             }
         }
@@ -262,29 +518,67 @@
 
     release_smbc(h, smbc);
     
+    VSs__end_task( animatingSlv );
 }
 
+VSsTaskType release_ref_list_taskType = {
+    .fn = &release_ref_list_task,
+    .numCtldArgs = 4,
+    .numTotalArgs = 6,
+    .sizeOfArgs = sizeof(release_ref_list_taskArgs),
+    .argTypes = release_ref_list_taskArgTypes,
+    .argSizes = release_ref_list_taskArgSizes};
+
 // 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){
 //
 // }
 /*-------------------------------------------------------------------------------*/
 //end for static 3d wave
 
-#pragma omp task inout (*oc) input(*sbe)
-static void output_task(H264Context *h, OutputContext *oc, SliceBufferEntry *sbe){
+typedef struct{
+    OutputContext *oc;
+    SliceBufferEntry *sbe; 
+    H264Context *h;
+} output_taskArgs;
+
+int32 output_taskArgTypes[3] = {INOUT, IN, NONCTLD};
+int32 output_taskArgSizes[3] = {sizeof(OutputContext), sizeof(SliceBufferEntry), sizeof(H264Context)};
+
+//#pragma omp task inout (*oc) input(*sbe)
+static void output_task(void *_data, SlaveVP *animatingSlv){
+    output_taskArgs* args = (output_taskArgs*) _data;
+    OutputContext *oc = args->oc;
+    SliceBufferEntry *sbe = args->sbe; 
+    H264Context *h = args->h;
+    
     DecodedPicture* out =output_frame(h, oc, sbe->slice.curr_pic, h->ofile, h->frame_width, h->frame_height);
     if (out){
-        #pragma omp critical (dpb)
+        //#pragma omp critical (dpb)
+        VSs__start_critical(animatingSlv,0);
         release_dpb_entry(h, out, 1);
+        VSs__end_critical(animatingSlv,0);
     }
     print_report(oc->frame_number, oc->video_size, 0, h->verbose);
+    
+    VSs__end_task( animatingSlv );
 }
 
+VSsTaskType output_taskType = {
+    .fn = &output_task,
+    .numCtldArgs = 2,
+    .numTotalArgs = 3,
+    .sizeOfArgs = sizeof(output_taskArgs),
+    .argTypes = output_taskArgTypes,
+    .argSizes = output_taskArgSizes};
+
 /*
 * The following code is the main loop of the file converter
 */
 //Put VMS entry point here
-int h264_decode_ompss( H264Context *h) {
+
+void h264_decode_ompss( void *_params, SlaveVP *animSlv) {
+    H264Context* h = (H264Context*) _params;
+    
     const int bufs = h->pipe_bufs;
 
     ParserContext *pc;
@@ -304,9 +598,11 @@
         pthread_create(&sdl_thr, NULL, sdl_thread, h);
     }
 #endif
+    /*sbe= VMS_WL__malloc(sizeof(SliceBufferEntry) * bufs);
+    if (sbe)
+        memset(sbe, 0, sizeof(SliceBufferEntry) * bufs);*/
     sbe= av_mallocz(sizeof(SliceBufferEntry) * bufs);
 
-
     pc = get_parse_context(h->ifile);
     nc = get_nal_context(h->width, h->height);
 
@@ -325,52 +621,135 @@
     if (h->static_3d && bufs < h->num_frames ){
         int num_pre_ed =0;
         for (num_pre_ed=0; num_pre_ed< bufs -1 && !pc->final_frame; num_pre_ed++){
-            parse_task( h, pc, nc, &sbe[k%bufs] );
-            decode_slice_entropy_task(h, ec[k%bufs], &sbe[k%bufs]);
-            #pragma omp taskwait on(*pc)
+            parse_taskArgs parse_task_args;
+            parse_task_args.h = h;
+            parse_task_args.pc = pc;
+            parse_task_args.nc = nc;
+            parse_task_args.sbe = &sbe[k%bufs];
+            VSs__submit_task(&parse_taskType, &parse_task_args, animSlv);
+            
+            decode_slice_entropy_taskArgs decode_slice_entropy_task_args;
+            decode_slice_entropy_task_args.h = h;
+            decode_slice_entropy_task_args.ec = ec[k%bufs];
+            decode_slice_entropy_task_args.sbe = &sbe[k%bufs];
+            VSs__submit_task(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, animSlv);        
+            //#pragma omp taskwait on(*pc)
+            VSs__taskwait_on(animSlv,pc);
             k++;
         }
 
         while(!pc->final_frame && frames++ < h->num_frames && !h->quit){
-            parse_task( h, pc, nc, &sbe[k%bufs] );
-            decode_slice_entropy_task(h, ec[k%bufs], &sbe[k%bufs]);
+            parse_taskArgs parse_task_args;
+            parse_task_args.h = h;
+            parse_task_args.pc = pc;
+            parse_task_args.nc = nc;
+            parse_task_args.sbe = &sbe[k%bufs];
+            VSs__submit_task(&parse_taskType, &parse_task_args, animSlv);
+            
+            decode_slice_entropy_taskArgs decode_slice_entropy_task_args;
+            decode_slice_entropy_task_args.h = h;
+            decode_slice_entropy_task_args.ec = ec[k%bufs];
+            decode_slice_entropy_task_args.sbe = &sbe[k%bufs];
+            VSs__submit_task(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, animSlv); 
 
             k++;
+            
+            init_ref_list_and_get_dpb_taskArgs init_ref_list_and_get_dpb_task_args;
+            init_ref_list_and_get_dpb_task_args.h = h;
+            init_ref_list_and_get_dpb_task_args.d = rc[k%2];
+            init_ref_list_and_get_dpb_task_args.sbe = &sbe[k%bufs];
+            init_ref_list_and_get_dpb_task_args.init = &init;
+            VSs__submit_task(&init_ref_list_and_get_dpb_taskType, &init_ref_list_and_get_dpb_task_args, animSlv); 
 
-            init_ref_list_and_get_dpb_task(h, rc[k%2], &sbe[k%bufs], &init);
             smbc = acquire_smbc(h);
-            SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc);
-            release_ref_list_task(h, smbc, rc[k%2], &sbe[k%bufs], lastsmb, &release);
+            SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc, animSlv);
+            release_ref_list_taskArgs release_ref_list_task_args;
+            release_ref_list_task_args.h = h;
+            release_ref_list_task_args.smbc = smbc;
+            release_ref_list_task_args.d = rc[k%2];
+            release_ref_list_task_args.sbe = &sbe[k%bufs];
+            release_ref_list_task_args.lastsmb = lastsmb;
+            release_ref_list_task_args.release = &release;
+            VSs__submit_task(&release_ref_list_taskType, &release_ref_list_task_args, animSlv);
 
-            output_task (h, oc, &sbe[k%bufs]);
-            #pragma omp taskwait on(*pc)
+            output_taskArgs output_task_args;
+            output_task_args.h = h;
+            output_task_args.oc = oc;
+            output_task_args.sbe = &sbe[k%bufs];
+            VSs__submit_task(&output_taskType, &output_task_args, animSlv);
+            //#pragma omp taskwait on(*pc)
+            VSs__taskwait_on(animSlv,pc);
         }
 
         for (int i=0; i< num_pre_ed; i++){
             k++;
-            init_ref_list_and_get_dpb_task(h, rc[k%2], &sbe[k%bufs], &init);
+            init_ref_list_and_get_dpb_taskArgs init_ref_list_and_get_dpb_task_args;
+            init_ref_list_and_get_dpb_task_args.h = h;
+            init_ref_list_and_get_dpb_task_args.d = rc[k%2];
+            init_ref_list_and_get_dpb_task_args.sbe = &sbe[k%bufs];
+            init_ref_list_and_get_dpb_task_args.init = &init;
+            VSs__submit_task(&init_ref_list_and_get_dpb_taskType, &init_ref_list_and_get_dpb_task_args, animSlv); 
             smbc = acquire_smbc(h);
-            SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc);
-            release_ref_list_task(h, smbc, rc[k%2], &sbe[k%bufs], lastsmb, &release);
+            SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc, animSlv);
+            release_ref_list_taskArgs release_ref_list_task_args;
+            release_ref_list_task_args.h = h;
+            release_ref_list_task_args.smbc = smbc;
+            release_ref_list_task_args.d = rc[k%2];
+            release_ref_list_task_args.sbe = &sbe[k%bufs];
+            release_ref_list_task_args.lastsmb = lastsmb;
+            release_ref_list_task_args.release = &release;
+            VSs__submit_task(&release_ref_list_taskType, &release_ref_list_task_args, animSlv); 
 
-            output_task (h, oc, &sbe[k%bufs]);
+            output_taskArgs output_task_args;
+            output_task_args.h = h;
+            output_task_args.oc = oc;
+            output_task_args.sbe = &sbe[k%bufs];
+            VSs__submit_task(&output_taskType, &output_task_args, animSlv);
         }
 
     } else {
         while(!pc->final_frame && frames++ < h->num_frames && !h->quit){
-            parse_task( h, pc, nc, &sbe[k%bufs] );
+            int32* taskID;
+            taskID = VSs__create_taskID_of_size(1,animSlv );
+            taskID[1] = frames*10+1;
+            parse_taskArgs parse_task_args;
+            parse_task_args.h = h;
+            parse_task_args.pc = pc;
+            parse_task_args.nc = nc;
+            parse_task_args.sbe = &sbe[k%bufs];
+            VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, taskID, animSlv);
 
-            decode_slice_entropy_task(h, ec[k%bufs], &sbe[k%bufs]);
+            taskID = VSs__create_taskID_of_size(1,animSlv );
+            taskID[1] = frames*10+2;
+            decode_slice_entropy_taskArgs decode_slice_entropy_task_args;
+            decode_slice_entropy_task_args.h = h;
+            decode_slice_entropy_task_args.ec = ec[k%bufs];
+            decode_slice_entropy_task_args.sbe = &sbe[k%bufs];
+            VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args,taskID, animSlv);
 
-            decode_slice_mb_task(h, rc[0], &sbe[k%bufs]);
+            taskID = VSs__create_taskID_of_size(1,animSlv );
+            taskID[1] = frames*10+3;
+            decode_slice_mb_taskArgs decode_slice_mb_task_args;
+            decode_slice_mb_task_args.h = h;
+            decode_slice_mb_task_args.d = rc[0];
+            decode_slice_mb_task_args.sbe = &sbe[k%bufs];
+            VSs__submit_task_with_ID(&decode_slice_mb_taskType, &decode_slice_mb_task_args,taskID, animSlv); 
 
-            output_task (h, oc, &sbe[k%bufs]);
-            #pragma omp taskwait on(*pc)
+            taskID = VSs__create_taskID_of_size(1,animSlv );
+            taskID[1] = frames*10+4;
+            output_taskArgs output_task_args;
+            output_task_args.h = h;
+            output_task_args.oc = oc;
+            output_task_args.sbe = &sbe[k%bufs];
+            VSs__submit_task_with_ID(&output_taskType, &output_task_args,taskID, animSlv);
+            //#pragma omp taskwait on(*pc)
+            VSs__taskwait_on(animSlv,pc);
             k++;
         }
     }
-    #pragma omp taskwait
-
+    //#pragma omp taskwait
+    VSs__taskwait(animSlv);
+    
     while ((out=output_frame(h, oc, NULL, h->ofile, h->frame_width, h->frame_height))) ;
 
     print_report(oc->frame_number, oc->video_size, 1, h->verbose);
@@ -397,5 +776,5 @@
     }
 #endif
 
-    return 0;
+    VSs__end_thread( animSlv );
 }