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

annotate 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
rev   line source
nengel@2 1 /*
nengel@2 2 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
nengel@2 3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
nengel@2 4 *
nengel@2 5 * This file is part of FFmpeg.
nengel@2 6 *
nengel@2 7 * FFmpeg is free software; you can redistribute it and/or
nengel@2 8 * modify it under the terms of the GNU Lesser General Public
nengel@2 9 * License as published by the Free Software Foundation; either
nengel@2 10 * version 2.1 of the License, or (at your option) any later version.
nengel@2 11 *
nengel@2 12 * FFmpeg is distributed in the hope that it will be useful,
nengel@2 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
nengel@2 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
nengel@2 15 * Lesser General Public License for more details.
nengel@2 16 *
nengel@2 17 * You should have received a copy of the GNU Lesser General Public
nengel@2 18 * License along with FFmpeg; if not, write to the Free Software
nengel@2 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
nengel@2 20 */
nengel@2 21 #include "h264_types.h"
nengel@2 22 #include "h264_parser.h"
nengel@2 23 #include "h264_nal.h"
nengel@2 24 #include "h264_entropy.h"
nengel@2 25 #include "h264_rec.h"
nengel@2 26 #include "h264_pred_mode.h"
nengel@2 27 #include "h264_misc.h"
nengel@2 28 // #undef NDEBUG
nengel@2 29 #include <assert.h>
nengel@3 30 #include "VSs_impl/VSs.h"
nengel@2 31
nengel@3 32 typedef struct{
nengel@3 33 ParserContext *pc;
nengel@3 34 NalContext *nc;
nengel@3 35 SliceBufferEntry *sbe;
nengel@3 36 H264Context *h;
nengel@3 37 } parse_taskArgs;
nengel@3 38
nengel@9 39 int32 parse_taskArgTypes[3] = {INOUT, INOUT, OUTPUT};
nengel@9 40 size_t parse_taskArgSizes[3] = {sizeof(ParserContext), sizeof(NalContext), sizeof(SliceBufferEntry)};
nengel@3 41
nengel@3 42 //#pragma omp task inout(*pc, *nc) output(*sbe)
nengel@7 43 static void parse_task(void *_data){
nengel@3 44 parse_taskArgs* args = (parse_taskArgs*) _data;
nengel@3 45 ParserContext *pc = args->pc;
nengel@3 46 NalContext *nc = args->nc;
nengel@3 47 SliceBufferEntry *sbe = args->sbe;
nengel@3 48 H264Context *h = args->h;
nengel@2 49 H264Slice *s;
nengel@2 50
nengel@2 51 if (!sbe->initialized){
nengel@2 52 init_sb_entry(h, sbe);
nengel@2 53 sbe->lines_total=h->mb_height;
nengel@2 54 }
nengel@2 55
nengel@2 56 av_read_frame_internal(pc, &sbe->gb);
nengel@2 57 s = &sbe->slice;
nengel@2 58
nengel@2 59 decode_nal_units(nc, s, &sbe->gb);
nengel@3 60
nengel@8 61 return;
nengel@2 62 }
nengel@2 63
nengel@3 64 VSsTaskType parse_taskType = {
nengel@3 65 .fn = &parse_task,
nengel@9 66 .numDeps = 3,
nengel@3 67 .sizeOfArgs = sizeof(parse_taskArgs),
nengel@9 68 .depsTypes = parse_taskArgTypes,
nengel@9 69 .depsSizes = parse_taskArgSizes};
nengel@3 70
nengel@3 71
nengel@3 72 typedef struct{
nengel@3 73 EntropyContext *ec;
nengel@3 74 SliceBufferEntry *sbe;
nengel@3 75 H264Context *h;
nengel@3 76 } decode_slice_entropy_taskArgs;
nengel@3 77
nengel@9 78 int32 decode_slice_entropy_taskArgTypes[2] = {INOUT, INOUT};
nengel@9 79 size_t decode_slice_entropy_taskArgSizes[2] = {sizeof(EntropyContext), sizeof(SliceBufferEntry)};
nengel@3 80
nengel@3 81 //#pragma omp task inout(*ec) inout(*sbe)
nengel@7 82 static void decode_slice_entropy_task(void *_data){
nengel@3 83 decode_slice_entropy_taskArgs* args = (decode_slice_entropy_taskArgs*) _data;
nengel@3 84 EntropyContext *ec = args->ec;
nengel@3 85 SliceBufferEntry *sbe = args->sbe;
nengel@3 86 H264Context *h = args->h;
nengel@2 87 int i,j;
nengel@2 88 H264Slice *s = &sbe->slice;
nengel@2 89 GetBitContext *gb = &sbe->gb;
nengel@2 90 H264Mb *mbs = sbe->mbs;
nengel@2 91 // GetBitContext *gb = s->gb;
nengel@2 92 CABACContext *c = &ec->c;
nengel@2 93
nengel@2 94 if( !s->pps.cabac ){
nengel@2 95 av_log(AV_LOG_ERROR, "Only cabac encoded streams are supported\n");
nengel@8 96 return;
nengel@2 97 }
nengel@2 98
nengel@2 99 init_dequant_tables(s, ec);
nengel@2 100 ec->curr_qscale = s->qscale;
nengel@2 101 ec->last_qscale_diff = 0;
nengel@2 102 ec->chroma_qp[0] = get_chroma_qp((H264Slice *) s, 0, s->qscale);
nengel@2 103 ec->chroma_qp[1] = get_chroma_qp((H264Slice *) s, 1, s->qscale);
nengel@2 104
nengel@2 105 /* realign */
nengel@2 106 align_get_bits( gb );
nengel@2 107 /* init cabac */
nengel@2 108 ff_init_cabac_decoder( c, gb->buffer + get_bits_count(gb)/8, (get_bits_left(gb) + 7)/8);
nengel@2 109
nengel@2 110 ff_h264_init_cabac_states(ec, s, c);
nengel@2 111
nengel@2 112 for(j=0; j<ec->mb_height; j++){
nengel@2 113 init_entropy_buf(ec, s, j);
nengel@2 114 for(i=0; i<ec->mb_width; i++){
nengel@2 115 int eos,ret;
nengel@2 116 H264Mb *m = &mbs[i + j*ec->mb_width];
nengel@2 117 m->mb_x=i;
nengel@2 118 m->mb_y=j;
nengel@2 119 ec->m = m;
nengel@2 120
nengel@2 121 ret = ff_h264_decode_mb_cabac(ec, s, c);
nengel@2 122 eos = get_cabac_terminate( c);
nengel@2 123 (void) eos;
nengel@2 124 if( ret < 0 || c->bytestream > c->bytestream_end + 2) {
nengel@2 125 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);
nengel@8 126 return;
nengel@2 127 }
nengel@2 128 }
nengel@2 129 }
nengel@8 130 return;
nengel@2 131 }
nengel@2 132
nengel@3 133 VSsTaskType decode_slice_entropy_taskType = {
nengel@3 134 .fn = &decode_slice_entropy_task,
nengel@9 135 .numDeps = 2,
nengel@3 136 .sizeOfArgs = sizeof(decode_slice_entropy_taskArgs),
nengel@9 137 .depsTypes = decode_slice_entropy_taskArgTypes,
nengel@9 138 .depsSizes = decode_slice_entropy_taskArgSizes};
nengel@3 139
nengel@3 140
nengel@2 141 static void decode_super_mb_block(MBRecContext *d, H264Slice *s, SuperMBContext *smbc, H264Mb *mbs, int smb_x, int smb_y){
nengel@2 142 MBRecState mrs;
nengel@2 143 // memset(&mrs, 0, sizeof(MBRecState));
nengel@2 144
nengel@2 145 for (int k=0, i= smb_y; i< smb_y + smbc->smb_height; i++, k++){
nengel@2 146 init_mbrec_context(d, &mrs, s, i);
nengel@2 147 for (int j= smb_x -k ; j< smb_x - k + smbc->smb_width; j++){
nengel@2 148 if (i< d->mb_height && j >= 0 && j < d->mb_width){
nengel@2 149 h264_decode_mb_internal (d, &mrs, s, &mbs[i*d->mb_width+j]);
nengel@2 150 }
nengel@2 151 }
nengel@2 152 }
nengel@2 153 }
nengel@2 154
nengel@3 155 typedef struct{
nengel@3 156 MBRecContext *d;
nengel@3 157 SliceBufferEntry *sbe;
nengel@3 158 SuperMBTask *ml;
nengel@3 159 SuperMBTask *mur;
nengel@3 160 SuperMBTask *m;
nengel@3 161 SuperMBContext *smbc;
nengel@3 162 } decode_super_mb_taskArgs;
nengel@3 163
nengel@9 164 int32 decode_super_mb_taskArgTypes[5] = {IN, IN, IN, IN, INOUT};
nengel@9 165 size_t decode_super_mb_taskArgSizes[5] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask)};
nengel@3 166
nengel@3 167 //#pragma omp task input(*d, *sbe, *ml, *mur) inout(*m)
nengel@7 168 static void decode_super_mb_task(void *_data){
nengel@3 169 decode_super_mb_taskArgs* args = (decode_super_mb_taskArgs*) _data;
nengel@3 170 MBRecContext *d = args->d;
nengel@3 171 SliceBufferEntry *sbe = args->sbe;
nengel@3 172 SuperMBTask *ml = args->ml;
nengel@3 173 SuperMBTask *mur = args->mur;
nengel@3 174 SuperMBTask *m = args->m;
nengel@3 175 SuperMBContext *smbc = args->smbc;
nengel@2 176 H264Slice *s = &sbe->slice;
nengel@2 177 H264Mb *mbs = sbe->mbs;
nengel@2 178 decode_super_mb_block(d, s, smbc, mbs, m->smb_x, m->smb_y);
nengel@8 179 return;
nengel@2 180 }
nengel@2 181
nengel@3 182 VSsTaskType decode_super_mb_taskType = {
nengel@3 183 .fn = &decode_super_mb_task,
nengel@9 184 .numDeps = 5,
nengel@3 185 .sizeOfArgs = sizeof(decode_super_mb_taskArgs),
nengel@9 186 .depsTypes = decode_super_mb_taskArgTypes,
nengel@9 187 .depsSizes = decode_super_mb_taskArgSizes};
nengel@3 188
nengel@3 189
nengel@3 190
nengel@3 191 typedef struct{
nengel@3 192 MBRecContext *d;
nengel@3 193 SliceBufferEntry *sbe;
nengel@3 194 SuperMBTask *sm;
nengel@3 195 SuperMBContext *smbc;
nengel@3 196 int* line;
nengel@3 197 } draw_edges_taskArgs;
nengel@3 198
nengel@9 199 int32 draw_edges_taskArgTypes[3] = {IN, IN, INOUT};
nengel@9 200 size_t draw_edges_taskArgSizes[3] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask)};
nengel@3 201
nengel@3 202 //#pragma omp task input(*d, *sbe) inout(*sm)
nengel@7 203 static void draw_edges_task(void *_data){
nengel@3 204 draw_edges_taskArgs* args = (draw_edges_taskArgs*) _data;
nengel@3 205 MBRecContext *d = args->d;
nengel@3 206 SliceBufferEntry *sbe = args->sbe;
nengel@3 207 SuperMBTask *sm = args->sm;
nengel@3 208 SuperMBContext *smbc = args->smbc;
nengel@3 209 int line = *(args->line);
nengel@2 210 H264Slice *s = &sbe->slice;
nengel@2 211 for (int i=line*smbc->smb_height; i< (line+1)*smbc->smb_height && i< d->mb_height; i++)
nengel@2 212 draw_edges(d, s, i);
nengel@6 213 VMS_App__free(args->line);
nengel@8 214 return;
nengel@2 215 }
nengel@3 216 VSsTaskType draw_edges_taskType = {
nengel@3 217 .fn = &draw_edges_task,
nengel@9 218 .numDeps = 3,
nengel@3 219 .sizeOfArgs = sizeof(draw_edges_taskArgs),
nengel@9 220 .depsTypes = draw_edges_taskArgTypes,
nengel@9 221 .depsSizes = draw_edges_taskArgSizes};
nengel@2 222
nengel@3 223
nengel@7 224 static void decode_mb_in_slice(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe){
nengel@2 225 int i,j;
nengel@2 226
nengel@2 227 SuperMBContext *smbc = acquire_smbc(h);
nengel@2 228 int smb_height =smbc->nsmb_height, smb_width= smbc->nsmb_width;
nengel@2 229 SuperMBTask *smbs = smbc->smbs[0];
nengel@2 230
nengel@2 231 SuperMBTask *sm=NULL, *sml, *smur;
nengel@2 232 for(j=0; j< smb_height; j++){
nengel@2 233 for(i=0; i< smb_width; i++){
nengel@2 234 sm = smbs + j*smb_width + i;
nengel@2 235 sml = sm - ((i > 0) ? 1: 0);
nengel@2 236 smur = sm + (((i < smb_width-1) && (j >0)) ? -smb_width+1: 0);
nengel@3 237 decode_super_mb_taskArgs decode_super_mb_task_args;
nengel@3 238 decode_super_mb_task_args.d = d;
nengel@3 239 decode_super_mb_task_args.sbe = sbe;
nengel@3 240 decode_super_mb_task_args.smbc = smbc;
nengel@3 241 decode_super_mb_task_args.ml = sml;
nengel@3 242 decode_super_mb_task_args.mur = smur;
nengel@3 243 decode_super_mb_task_args.m = sm;
nengel@9 244 void** depsAddrs = malloc(decode_super_mb_taskType.numDeps * sizeof(void*));
nengel@9 245 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask)*/
nengel@9 246 depsAddrs[0] = d;
nengel@9 247 depsAddrs[1] = sbe;
nengel@9 248 depsAddrs[2] = sml;
nengel@9 249 depsAddrs[3] = smur;
nengel@9 250 depsAddrs[4] = sm;
nengel@9 251 VSs__submit_task(&decode_super_mb_taskType, &decode_super_mb_task_args, depsAddrs);
nengel@2 252 }
nengel@3 253 draw_edges_taskArgs draw_edges_task_args;
nengel@3 254 draw_edges_task_args.d = d;
nengel@3 255 draw_edges_task_args.sbe = sbe;
nengel@3 256 draw_edges_task_args.sm = sm;
nengel@3 257 draw_edges_task_args.smbc = smbc;
nengel@3 258 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) );
nengel@3 259 *(draw_edges_task_args.line) = j;
nengel@9 260 void** depsAddrs = malloc(sizeof (void*) * draw_edges_taskType.numDeps);
nengel@9 261 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask)*/
nengel@9 262 depsAddrs[0] = d;
nengel@9 263 depsAddrs[1] = sbe;
nengel@9 264 depsAddrs[2] = sm;
nengel@9 265 VSs__submit_task(&draw_edges_taskType, &draw_edges_task_args, depsAddrs);
nengel@2 266 }
nengel@7 267 VSs__taskwait_on(sm);
nengel@3 268 //#pragma omp taskwait on(*sm)
nengel@2 269
nengel@2 270 release_smbc(h, smbc);
nengel@2 271 }
nengel@2 272
nengel@3 273 typedef struct{
nengel@3 274 MBRecContext *d;
nengel@3 275 SliceBufferEntry *sbe;
nengel@3 276 H264Context *h;
nengel@3 277 } decode_slice_mb_taskArgs;
nengel@3 278
nengel@9 279 int32 decode_slice_mb_taskArgTypes[2] = {INOUT, INOUT};
nengel@9 280 size_t decode_slice_mb_taskArgSizes[2] = {sizeof(MBRecContext), sizeof(SliceBufferEntry)};
nengel@3 281
nengel@3 282 //#pragma omp task inout(*d) inout(*sbe)
nengel@7 283 static void decode_slice_mb_task(void *_data){
nengel@3 284 decode_slice_mb_taskArgs* args = (decode_slice_mb_taskArgs*) _data;
nengel@3 285 MBRecContext *d = args->d;
nengel@3 286 SliceBufferEntry *sbe = args->sbe;
nengel@3 287 H264Context *h = args->h;
nengel@3 288
nengel@2 289 H264Slice *s = &sbe->slice;
nengel@2 290
nengel@2 291 for (int i=0; i<2; i++){
nengel@2 292 for(int j=0; j< s->ref_count[i]; j++){
nengel@2 293 if (s->ref_list_cpn[i][j] ==-1)
nengel@2 294 continue;
nengel@2 295 int k;
nengel@2 296 for (k=0; k< h->max_dpb_cnt; k++){
nengel@2 297 if(h->dpb[k].reference >= 2 && h->dpb[k].cpn == s->ref_list_cpn[i][j]){
nengel@2 298 s->dp_ref_list[i][j] = &h->dpb[k];
nengel@2 299 break;
nengel@2 300 }
nengel@2 301 }
nengel@2 302 }
nengel@2 303 }
nengel@2 304
nengel@3 305 //#pragma omp critical (dpb)
nengel@7 306 VSs__start_critical(0);
nengel@2 307 get_dpb_entry(h, s);
nengel@7 308 VSs__end_critical(0);
nengel@3 309
nengel@2 310 if (!h->no_mbd){
nengel@7 311 decode_mb_in_slice (h, d, sbe);
nengel@2 312 }
nengel@2 313
nengel@2 314 for (int i=0; i<s->release_cnt; i++){
nengel@2 315 for(int j=0; j<h->max_dpb_cnt; j++){
nengel@2 316 if(h->dpb[j].cpn== s->release_ref_cpn[i]){
nengel@3 317 //#pragma omp critical (dpb)
nengel@7 318 VSs__start_critical(0);
nengel@2 319 release_dpb_entry(h, &h->dpb[j], 2);
nengel@7 320 VSs__end_critical(0);
nengel@2 321 break;
nengel@2 322 }
nengel@2 323 }
nengel@2 324 }
nengel@2 325 s->release_cnt=0;
nengel@8 326 return;
nengel@2 327 }
nengel@2 328
nengel@3 329 VSsTaskType decode_slice_mb_taskType = {
nengel@3 330 .fn = &decode_slice_mb_task,
nengel@9 331 .numDeps = 2,
nengel@3 332 .sizeOfArgs = sizeof(decode_slice_mb_taskArgs),
nengel@9 333 .depsTypes = decode_slice_mb_taskArgTypes,
nengel@9 334 .depsSizes = decode_slice_mb_taskArgSizes};
nengel@3 335
nengel@2 336 // for static 3d wave
nengel@2 337 /*-------------------------------------------------------------------------------*/
nengel@3 338 typedef struct{
nengel@3 339 MBRecContext *d;
nengel@3 340 SliceBufferEntry *sbe;
nengel@3 341 SuperMBTask *ml;
nengel@3 342 SuperMBTask *mur;
nengel@3 343 SuperMBTask *mprev;
nengel@3 344 SuperMBTask *m;
nengel@3 345 SuperMBContext *smbc;
nengel@3 346 } decode_3dwave_super_mb_taskArgs;
nengel@3 347
nengel@9 348 int32 decode_3dwave_super_mb_taskArgTypes[6] = {IN, IN, IN, IN, IN, INOUT};
nengel@9 349 size_t decode_3dwave_super_mb_taskArgSizes[6] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask),
nengel@9 350 sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask)};
nengel@3 351
nengel@3 352 //#pragma omp task input(*d, *sbe, *ml, *mur, *mprev) inout(*m)
nengel@7 353 static void decode_3dwave_super_mb_task(void *_data){
nengel@3 354 decode_3dwave_super_mb_taskArgs* args = (decode_3dwave_super_mb_taskArgs*) _data;
nengel@3 355 MBRecContext *d = args->d;
nengel@3 356 SliceBufferEntry *sbe = args->sbe;
nengel@3 357 SuperMBTask *ml = args->ml;
nengel@3 358 SuperMBTask *mur = args->mur;
nengel@3 359 SuperMBTask *mprev = args->mprev;
nengel@3 360 SuperMBTask *m = args->m;
nengel@3 361 SuperMBContext *smbc = args->smbc;
nengel@3 362
nengel@2 363 H264Slice *s = &sbe->slice;
nengel@2 364 H264Mb *mbs = sbe->mbs;
nengel@2 365
nengel@2 366 decode_super_mb_block(d, s, smbc, mbs, m->smb_x, m->smb_y);
nengel@8 367 return;
nengel@2 368 }
nengel@2 369
nengel@3 370 VSsTaskType decode_3dwave_super_mb_taskType = {
nengel@3 371 .fn = &decode_3dwave_super_mb_task,
nengel@9 372 .numDeps = 6,
nengel@3 373 .sizeOfArgs = sizeof(decode_3dwave_super_mb_taskArgs),
nengel@9 374 .depsTypes = decode_3dwave_super_mb_taskArgTypes,
nengel@9 375 .depsSizes = decode_3dwave_super_mb_taskArgSizes};
nengel@3 376
nengel@2 377 // int init_ref_count=0;
nengel@3 378 typedef struct{
nengel@3 379 MBRecContext *d;
nengel@3 380 SliceBufferEntry *sbe;
nengel@3 381 int* init;
nengel@3 382 H264Context *h;
nengel@3 383 } init_ref_list_and_get_dpb_taskArgs;
nengel@3 384
nengel@9 385 int32 init_ref_list_and_get_dpb_taskArgTypes[3] = {INOUT, INOUT, INOUT};
nengel@9 386 size_t init_ref_list_and_get_dpb_taskArgSizes[3] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(int)};
nengel@3 387
nengel@3 388 //#pragma omp task inout(*d, *sbe, *init)
nengel@7 389 static void init_ref_list_and_get_dpb_task(void *_data){
nengel@3 390 init_ref_list_and_get_dpb_taskArgs* args = (init_ref_list_and_get_dpb_taskArgs*) _data;
nengel@3 391 MBRecContext *d = args->d;
nengel@3 392 SliceBufferEntry *sbe = args->sbe;
nengel@3 393 int* initp = args->init;
nengel@3 394 H264Context *h = args->h;
nengel@3 395
nengel@2 396 H264Slice *s = &sbe->slice;
nengel@2 397 for (int i=0; i<2; i++){
nengel@2 398 for(int j=0; j< s->ref_count[i]; j++){
nengel@2 399 if (s->ref_list_cpn[i][j] ==-1)
nengel@2 400 continue;
nengel@2 401 int k;
nengel@2 402 for (k=0; k<h->max_dpb_cnt; k++){
nengel@2 403 if(h->dpb[k].reference >= 2 && h->dpb[k].cpn == s->ref_list_cpn[i][j]){
nengel@2 404 s->dp_ref_list[i][j] = &h->dpb[k];
nengel@2 405 break;
nengel@2 406 }
nengel@2 407 }
nengel@2 408 }
nengel@2 409 }
nengel@2 410
nengel@3 411 //#pragma omp critical (dpb)
nengel@7 412 VSs__start_critical(0);
nengel@2 413 get_dpb_entry(h, s);
nengel@7 414 VSs__end_critical(0);
nengel@3 415
nengel@8 416 return;
nengel@2 417 }
nengel@2 418
nengel@3 419 VSsTaskType init_ref_list_and_get_dpb_taskType = {
nengel@3 420 .fn = &init_ref_list_and_get_dpb_task,
nengel@9 421 .numDeps = 3,
nengel@3 422 .sizeOfArgs = sizeof(init_ref_list_and_get_dpb_taskArgs),
nengel@9 423 .depsTypes = init_ref_list_and_get_dpb_taskArgTypes,
nengel@9 424 .depsSizes = init_ref_list_and_get_dpb_taskArgSizes};
nengel@3 425
nengel@7 426 static SuperMBTask* add_decode_slice_3dwave_tasks(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, int k){
nengel@2 427 int i,j;
nengel@2 428
nengel@5 429 int32* taskID;
nengel@5 430
nengel@2 431 int smb_3d_height =smbc->nsmb_3dheight;
nengel@2 432 int smb_height =smbc->nsmb_height, smb_width= smbc->nsmb_width;
nengel@2 433 int smb_diff_prev = smb_height - smb_3d_height;
nengel@2 434 SuperMBTask *sm=NULL, *sml, *smur, *smprev;
nengel@2 435
nengel@2 436 SuperMBTask *smbs = smbc->smbs[smbc->index++]; smbc->index%=2;
nengel@2 437 SuperMBTask *smbs_prev = smbc->smbs[smbc->index]; // index rotates -> next == prev
nengel@2 438
nengel@2 439 for(j=0; j<smb_3d_height ; j++){
nengel@2 440 for(i=0; i< smb_width; i++){
nengel@2 441 sm = smbs + j*smb_width + i;
nengel@2 442 sml = sm - ((i > 0) ? 1: 0);
nengel@2 443 smur = sm + (((i < smb_width-1) && (j >0)) ? -smb_width+1: 0);
nengel@2 444 smprev = smbs_prev + (j + smb_diff_prev+1)*smb_width -1;
nengel@3 445 decode_3dwave_super_mb_taskArgs decode_3dwave_super_mb_task_args;
nengel@3 446 decode_3dwave_super_mb_task_args.d = d;
nengel@3 447 decode_3dwave_super_mb_task_args.sbe = sbe;
nengel@3 448 decode_3dwave_super_mb_task_args.smbc = smbc;
nengel@3 449 decode_3dwave_super_mb_task_args.ml = sml;
nengel@3 450 decode_3dwave_super_mb_task_args.mur = smur;
nengel@3 451 decode_3dwave_super_mb_task_args.mprev = smprev;
nengel@3 452 decode_3dwave_super_mb_task_args.m = sm;
nengel@7 453 taskID = VSs__create_taskID_of_size(3 );
nengel@9 454 void** depsAddrs = malloc(sizeof(void*) * decode_3dwave_super_mb_taskType.numDeps);
nengel@9 455 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask),
nengel@9 456 sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask)*/
nengel@9 457 depsAddrs[0] = d;
nengel@9 458 depsAddrs[1] = sbe;
nengel@9 459 depsAddrs[2] = sml;
nengel@9 460 depsAddrs[3] = smur;
nengel@9 461 depsAddrs[4] = smprev;
nengel@5 462 taskID[1] = k;
nengel@5 463 taskID[2] = j;
nengel@5 464 taskID[3] = i;
nengel@9 465 VSs__submit_task_with_ID(&decode_3dwave_super_mb_taskType, &decode_3dwave_super_mb_task_args, depsAddrs, taskID);
nengel@2 466 }
nengel@3 467 draw_edges_taskArgs draw_edges_task_args;
nengel@3 468 draw_edges_task_args.d = d;
nengel@3 469 draw_edges_task_args.sbe = sbe;
nengel@3 470 draw_edges_task_args.sm = sm;
nengel@3 471 draw_edges_task_args.smbc = smbc;
nengel@3 472 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) );
nengel@3 473 *(draw_edges_task_args.line) = j;
nengel@9 474 void** depsAddrs = malloc(sizeof (void*) * draw_edges_taskType.numDeps);
nengel@9 475 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask)*/
nengel@9 476 depsAddrs[0] = d;
nengel@9 477 depsAddrs[1] = sbe;
nengel@9 478 depsAddrs[2] = sm;
nengel@7 479 taskID = VSs__create_taskID_of_size(3);
nengel@5 480 taskID[1] = k;
nengel@5 481 taskID[2] = j;
nengel@5 482 taskID[3] = i;
nengel@9 483 VSs__submit_task_with_ID(&draw_edges_taskType, &draw_edges_task_args, depsAddrs, taskID);
nengel@2 484 }
nengel@2 485
nengel@2 486 for(; j< smb_height; j++){
nengel@2 487 for(i=0; i< smb_width; i++){
nengel@2 488 sm = smbs + j*smb_width + i;
nengel@2 489 sml = sm - ((i > 0) ? 1: 0);
nengel@2 490 smur = sm + (((i < smb_width-1) && (j >0)) ? -smb_width+1: 0);
nengel@3 491 decode_super_mb_taskArgs decode_super_mb_task_args;
nengel@3 492 decode_super_mb_task_args.d = d;
nengel@3 493 decode_super_mb_task_args.sbe = sbe;
nengel@3 494 decode_super_mb_task_args.smbc = smbc;
nengel@3 495 decode_super_mb_task_args.ml = sml;
nengel@3 496 decode_super_mb_task_args.mur = smur;
nengel@3 497 decode_super_mb_task_args.m = sm;
nengel@9 498 void** depsAddrs = malloc(sizeof(void*) * decode_super_mb_taskType.numDeps);
nengel@9 499 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(SuperMBTask), sizeof(SuperMBTask)*/
nengel@9 500 depsAddrs[0] = d;
nengel@9 501 depsAddrs[1] = sbe;
nengel@9 502 depsAddrs[2] = sml;
nengel@9 503 depsAddrs[3] = smur;
nengel@9 504 depsAddrs[4] = sm;
nengel@7 505 taskID = VSs__create_taskID_of_size(3 );
nengel@5 506 taskID[1] = k;
nengel@5 507 taskID[2] = j;
nengel@5 508 taskID[3] = i;
nengel@9 509 VSs__submit_task_with_ID(&decode_super_mb_taskType, &decode_super_mb_task_args, depsAddrs, taskID);
nengel@2 510 }
nengel@3 511 draw_edges_taskArgs draw_edges_task_args;
nengel@3 512 draw_edges_task_args.d = d;
nengel@3 513 draw_edges_task_args.sbe = sbe;
nengel@3 514 draw_edges_task_args.sm = sm;
nengel@3 515 draw_edges_task_args.smbc = smbc;
nengel@3 516 draw_edges_task_args.line = VMS_App__malloc( sizeof(int) );
nengel@3 517 *(draw_edges_task_args.line) = j;
nengel@9 518 void** depsAddrs = malloc(sizeof (void*) * draw_edges_taskType.numDeps);
nengel@9 519 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask)*/
nengel@9 520 depsAddrs[0] = d;
nengel@9 521 depsAddrs[1] = sbe;
nengel@9 522 depsAddrs[2] = sm;
nengel@7 523 taskID = VSs__create_taskID_of_size(3);
nengel@5 524 taskID[1] = k;
nengel@5 525 taskID[2] = j;
nengel@5 526 taskID[3] = i;
nengel@9 527 VSs__submit_task_with_ID(&draw_edges_taskType, &draw_edges_task_args, depsAddrs, taskID);
nengel@2 528 }
nengel@2 529 return sm;
nengel@2 530 }
nengel@2 531
nengel@3 532 typedef struct{
nengel@3 533 MBRecContext *d;
nengel@3 534 SliceBufferEntry *sbe;
nengel@3 535 SuperMBTask *lastsmb;
nengel@3 536 int* release;
nengel@3 537 H264Context *h;
nengel@3 538 SuperMBContext *smbc;
nengel@3 539 } release_ref_list_taskArgs;
nengel@3 540
nengel@9 541 int32 release_ref_list_taskArgTypes[4] = {INOUT, INOUT, IN, INOUT};
nengel@9 542 size_t release_ref_list_taskArgSizes[4] = {sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(int)};
nengel@3 543
nengel@3 544 //#pragma omp task inout(*d, *sbe, *release) input (*lastsmb)
nengel@7 545 static void release_ref_list_task(void *_data){
nengel@3 546 release_ref_list_taskArgs* args = (release_ref_list_taskArgs*) _data;
nengel@3 547 MBRecContext *d = args->d;
nengel@3 548 SliceBufferEntry *sbe = args->sbe;
nengel@3 549 SuperMBTask *lastsmb = args->lastsmb;
nengel@3 550 int* releasep = args->release;
nengel@3 551 H264Context *h = args->h;
nengel@3 552 SuperMBContext *smbc = args->smbc;
nengel@3 553
nengel@2 554 H264Slice *s = &sbe->slice;
nengel@2 555 for (int i=0; i<s->release_cnt; i++){
nengel@2 556 for(int j=0; j<h->max_dpb_cnt; j++){
nengel@2 557 if(h->dpb[j].cpn== s->release_ref_cpn[i]){
nengel@3 558 //#pragma omp critical (dpb)
nengel@7 559 VSs__start_critical(0);
nengel@2 560 release_dpb_entry(h, &h->dpb[j], 2);
nengel@7 561 VSs__end_critical(0);
nengel@2 562 break;
nengel@2 563 }
nengel@2 564 }
nengel@2 565 }
nengel@2 566 s->release_cnt=0;
nengel@2 567
nengel@2 568 release_smbc(h, smbc);
nengel@2 569
nengel@8 570 return;
nengel@2 571 }
nengel@2 572
nengel@3 573 VSsTaskType release_ref_list_taskType = {
nengel@3 574 .fn = &release_ref_list_task,
nengel@9 575 .numDeps = 4,
nengel@3 576 .sizeOfArgs = sizeof(release_ref_list_taskArgs),
nengel@9 577 .depsTypes = release_ref_list_taskArgTypes,
nengel@9 578 .depsSizes = release_ref_list_taskArgSizes};
nengel@3 579
nengel@2 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){
nengel@2 581 //
nengel@2 582 // }
nengel@2 583 /*-------------------------------------------------------------------------------*/
nengel@2 584 //end for static 3d wave
nengel@2 585
nengel@3 586 typedef struct{
nengel@3 587 OutputContext *oc;
nengel@3 588 SliceBufferEntry *sbe;
nengel@3 589 H264Context *h;
nengel@3 590 } output_taskArgs;
nengel@3 591
nengel@9 592 int32 output_taskArgTypes[2] = {INOUT, IN};
nengel@9 593 size_t output_taskArgSizes[2] = {sizeof(OutputContext), sizeof(SliceBufferEntry)};
nengel@3 594
nengel@3 595 //#pragma omp task inout (*oc) input(*sbe)
nengel@7 596 static void output_task(void *_data){
nengel@3 597 output_taskArgs* args = (output_taskArgs*) _data;
nengel@3 598 OutputContext *oc = args->oc;
nengel@3 599 SliceBufferEntry *sbe = args->sbe;
nengel@3 600 H264Context *h = args->h;
nengel@3 601
nengel@2 602 DecodedPicture* out =output_frame(h, oc, sbe->slice.curr_pic, h->ofile, h->frame_width, h->frame_height);
nengel@2 603 if (out){
nengel@3 604 //#pragma omp critical (dpb)
nengel@7 605 VSs__start_critical(0);
nengel@2 606 release_dpb_entry(h, out, 1);
nengel@7 607 VSs__end_critical(0);
nengel@2 608 }
nengel@6 609 //print_report(oc->frame_number, oc->video_size, 0, h->verbose);
nengel@3 610
nengel@8 611 return;
nengel@2 612 }
nengel@2 613
nengel@3 614 VSsTaskType output_taskType = {
nengel@3 615 .fn = &output_task,
nengel@9 616 .numDeps = 2,
nengel@3 617 .sizeOfArgs = sizeof(output_taskArgs),
nengel@9 618 .depsTypes = output_taskArgTypes,
nengel@9 619 .depsSizes = output_taskArgSizes};
nengel@3 620
nengel@2 621 /*
nengel@2 622 * The following code is the main loop of the file converter
nengel@2 623 */
nengel@3 624
nengel@7 625 int h264_decode_ompss( H264Context *h) {
nengel@3 626
nengel@2 627 const int bufs = h->pipe_bufs;
nengel@2 628
nengel@2 629 ParserContext *pc;
nengel@2 630 NalContext *nc;
nengel@2 631 EntropyContext *ec[bufs];
nengel@2 632 MBRecContext *rc[2];
nengel@2 633 OutputContext *oc;
nengel@2 634 SliceBufferEntry *sbe;
nengel@2 635 SuperMBContext *smbc;
nengel@2 636
nengel@2 637 DecodedPicture *out;
nengel@2 638 int frames=0;
nengel@4 639
nengel@4 640 int32* taskID;
nengel@9 641 void** depsAddrs;
nengel@2 642
nengel@2 643 #if HAVE_LIBSDL2
nengel@2 644 pthread_t sdl_thr;
nengel@2 645 if (h->display){
nengel@2 646 pthread_create(&sdl_thr, NULL, sdl_thread, h);
nengel@2 647 }
nengel@2 648 #endif
nengel@3 649 /*sbe= VMS_WL__malloc(sizeof(SliceBufferEntry) * bufs);
nengel@3 650 if (sbe)
nengel@3 651 memset(sbe, 0, sizeof(SliceBufferEntry) * bufs);*/
nengel@2 652 sbe= av_mallocz(sizeof(SliceBufferEntry) * bufs);
nengel@2 653
nengel@2 654 pc = get_parse_context(h->ifile);
nengel@2 655 nc = get_nal_context(h->width, h->height);
nengel@2 656
nengel@2 657 for(int i=0; i<bufs; i++){
nengel@2 658 ec[i] = get_entropy_context( h );
nengel@2 659 }
nengel@2 660
nengel@2 661 for(int i=0; i<2; i++){
nengel@2 662 rc[i] = get_mbrec_context(h);
nengel@2 663 }
nengel@2 664
nengel@2 665 oc = get_output_context( h );
nengel@2 666
nengel@2 667 av_start_timer();
nengel@2 668 int k=0; int init, release;
nengel@2 669 if (h->static_3d && bufs < h->num_frames ){
nengel@2 670 int num_pre_ed =0;
nengel@2 671 for (num_pre_ed=0; num_pre_ed< bufs -1 && !pc->final_frame; num_pre_ed++){
nengel@3 672 parse_taskArgs parse_task_args;
nengel@3 673 parse_task_args.h = h;
nengel@3 674 parse_task_args.pc = pc;
nengel@3 675 parse_task_args.nc = nc;
nengel@3 676 parse_task_args.sbe = &sbe[k%bufs];
nengel@9 677 depsAddrs = malloc(sizeof(void*) * parse_taskType.numDeps);
nengel@9 678 /*sizeof(ParserContext), sizeof(NalContext), sizeof(SliceBufferEntry)*/
nengel@9 679 depsAddrs[0] = pc;
nengel@9 680 depsAddrs[1] = nc;
nengel@9 681 depsAddrs[2] = &sbe[k%bufs];
nengel@7 682 taskID = VSs__create_taskID_of_size(2);
nengel@4 683 taskID[1] = 1;
nengel@5 684 taskID[2] = k;
nengel@9 685 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, depsAddrs, taskID);
nengel@3 686
nengel@3 687 decode_slice_entropy_taskArgs decode_slice_entropy_task_args;
nengel@3 688 decode_slice_entropy_task_args.h = h;
nengel@3 689 decode_slice_entropy_task_args.ec = ec[k%bufs];
nengel@3 690 decode_slice_entropy_task_args.sbe = &sbe[k%bufs];
nengel@9 691 depsAddrs = malloc(sizeof(void*) * decode_slice_entropy_taskType.numDeps);
nengel@9 692 /*sizeof(EntropyContext), sizeof(SliceBufferEntry)*/
nengel@9 693 depsAddrs[0] = ec[k%bufs];
nengel@9 694 depsAddrs[1] = &sbe[k%bufs];
nengel@7 695 taskID = VSs__create_taskID_of_size(2);
nengel@4 696 taskID[1] = 2;
nengel@5 697 taskID[2] = k;
nengel@9 698 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, depsAddrs, taskID);
nengel@3 699 //#pragma omp taskwait on(*pc)
nengel@7 700 VSs__taskwait_on(pc);
nengel@2 701 k++;
nengel@2 702 }
nengel@2 703
nengel@2 704 while(!pc->final_frame && frames++ < h->num_frames && !h->quit){
nengel@3 705 parse_taskArgs parse_task_args;
nengel@3 706 parse_task_args.h = h;
nengel@3 707 parse_task_args.pc = pc;
nengel@3 708 parse_task_args.nc = nc;
nengel@3 709 parse_task_args.sbe = &sbe[k%bufs];
nengel@9 710 depsAddrs = malloc(sizeof(void*) * parse_taskType.numDeps);
nengel@9 711 /*sizeof(ParserContext), sizeof(NalContext), sizeof(SliceBufferEntry)*/
nengel@9 712 depsAddrs[0] = pc;
nengel@9 713 depsAddrs[1] = nc;
nengel@9 714 depsAddrs[2] = &sbe[k%bufs];
nengel@7 715 taskID = VSs__create_taskID_of_size(2);
nengel@4 716 taskID[1] = 3;
nengel@5 717 taskID[2] = k;
nengel@9 718 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, depsAddrs, taskID);
nengel@3 719
nengel@3 720 decode_slice_entropy_taskArgs decode_slice_entropy_task_args;
nengel@3 721 decode_slice_entropy_task_args.h = h;
nengel@3 722 decode_slice_entropy_task_args.ec = ec[k%bufs];
nengel@3 723 decode_slice_entropy_task_args.sbe = &sbe[k%bufs];
nengel@9 724 depsAddrs = malloc(sizeof(void*) * decode_slice_entropy_taskType.numDeps);
nengel@9 725 /*sizeof(EntropyContext), sizeof(SliceBufferEntry)*/
nengel@9 726 depsAddrs[0] = ec[k%bufs];
nengel@9 727 depsAddrs[1] = &sbe[k%bufs];
nengel@7 728 taskID = VSs__create_taskID_of_size(2);
nengel@4 729 taskID[1] = 4;
nengel@5 730 taskID[2] = k;
nengel@9 731 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, depsAddrs, taskID);
nengel@2 732
nengel@2 733 k++;
nengel@3 734
nengel@3 735 init_ref_list_and_get_dpb_taskArgs init_ref_list_and_get_dpb_task_args;
nengel@3 736 init_ref_list_and_get_dpb_task_args.h = h;
nengel@3 737 init_ref_list_and_get_dpb_task_args.d = rc[k%2];
nengel@3 738 init_ref_list_and_get_dpb_task_args.sbe = &sbe[k%bufs];
nengel@3 739 init_ref_list_and_get_dpb_task_args.init = &init;
nengel@9 740 depsAddrs = malloc(sizeof(void*) * init_ref_list_and_get_dpb_taskType.numDeps);
nengel@9 741 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(int)*/
nengel@9 742 depsAddrs[0] = rc[k%2];
nengel@9 743 depsAddrs[1] = &sbe[k%bufs];
nengel@9 744 depsAddrs[2] = &init;
nengel@7 745 taskID = VSs__create_taskID_of_size(2);
nengel@4 746 taskID[1] = 5;
nengel@5 747 taskID[2] = k;
nengel@9 748 VSs__submit_task_with_ID(&init_ref_list_and_get_dpb_taskType, &init_ref_list_and_get_dpb_task_args, depsAddrs, taskID);
nengel@2 749
nengel@2 750 smbc = acquire_smbc(h);
nengel@7 751 SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc, k);
nengel@3 752 release_ref_list_taskArgs release_ref_list_task_args;
nengel@3 753 release_ref_list_task_args.h = h;
nengel@3 754 release_ref_list_task_args.smbc = smbc;
nengel@3 755 release_ref_list_task_args.d = rc[k%2];
nengel@3 756 release_ref_list_task_args.sbe = &sbe[k%bufs];
nengel@3 757 release_ref_list_task_args.lastsmb = lastsmb;
nengel@3 758 release_ref_list_task_args.release = &release;
nengel@9 759 depsAddrs = malloc(sizeof(void*) * release_ref_list_taskType.numDeps);
nengel@9 760 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(int)*/
nengel@9 761 depsAddrs[0] = rc[k%2];
nengel@9 762 depsAddrs[1] = &sbe[k%bufs];
nengel@9 763 depsAddrs[2] = smbc;
nengel@9 764 depsAddrs[3] = &release;
nengel@7 765 taskID = VSs__create_taskID_of_size(2);
nengel@4 766 taskID[1] = 6;
nengel@5 767 taskID[2] = k;
nengel@9 768 VSs__submit_task_with_ID(&release_ref_list_taskType, &release_ref_list_task_args, depsAddrs, taskID);
nengel@2 769
nengel@3 770 output_taskArgs output_task_args;
nengel@3 771 output_task_args.h = h;
nengel@3 772 output_task_args.oc = oc;
nengel@3 773 output_task_args.sbe = &sbe[k%bufs];
nengel@9 774 depsAddrs = malloc(sizeof(void*) * output_taskType.numDeps);
nengel@9 775 /*sizeof(OutputContext), sizeof(SliceBufferEntry)*/
nengel@9 776 depsAddrs[0] = oc;
nengel@9 777 depsAddrs[1] = &sbe[k%bufs];
nengel@7 778 taskID = VSs__create_taskID_of_size(2);
nengel@4 779 taskID[1] = 7;
nengel@5 780 taskID[2] = k;
nengel@9 781 VSs__submit_task_with_ID(&output_taskType, &output_task_args, depsAddrs, taskID);
nengel@3 782 //#pragma omp taskwait on(*pc)
nengel@7 783 VSs__taskwait_on(pc);
nengel@2 784 }
nengel@2 785
nengel@2 786 for (int i=0; i< num_pre_ed; i++){
nengel@2 787 k++;
nengel@3 788 init_ref_list_and_get_dpb_taskArgs init_ref_list_and_get_dpb_task_args;
nengel@3 789 init_ref_list_and_get_dpb_task_args.h = h;
nengel@3 790 init_ref_list_and_get_dpb_task_args.d = rc[k%2];
nengel@3 791 init_ref_list_and_get_dpb_task_args.sbe = &sbe[k%bufs];
nengel@3 792 init_ref_list_and_get_dpb_task_args.init = &init;
nengel@9 793 depsAddrs = malloc(sizeof(void*) * init_ref_list_and_get_dpb_taskType.numDeps);
nengel@9 794 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(int)*/
nengel@9 795 depsAddrs[0] = rc[k%2];
nengel@9 796 depsAddrs[1] = &sbe[k%bufs];
nengel@9 797 depsAddrs[2] = &init;
nengel@7 798 taskID = VSs__create_taskID_of_size(2);
nengel@4 799 taskID[1] = 8;
nengel@4 800 taskID[2] = i;
nengel@9 801 VSs__submit_task_with_ID(&init_ref_list_and_get_dpb_taskType, &init_ref_list_and_get_dpb_task_args, depsAddrs, taskID);
nengel@2 802 smbc = acquire_smbc(h);
nengel@7 803 SuperMBTask *lastsmb= add_decode_slice_3dwave_tasks(rc[k%2], &sbe[k%bufs], smbc, k);
nengel@3 804 release_ref_list_taskArgs release_ref_list_task_args;
nengel@3 805 release_ref_list_task_args.h = h;
nengel@3 806 release_ref_list_task_args.smbc = smbc;
nengel@3 807 release_ref_list_task_args.d = rc[k%2];
nengel@3 808 release_ref_list_task_args.sbe = &sbe[k%bufs];
nengel@3 809 release_ref_list_task_args.lastsmb = lastsmb;
nengel@3 810 release_ref_list_task_args.release = &release;
nengel@9 811 depsAddrs = malloc(sizeof(void*) * release_ref_list_taskType.numDeps);
nengel@9 812 /*sizeof(MBRecContext), sizeof(SliceBufferEntry), sizeof(SuperMBTask), sizeof(int)*/
nengel@9 813 depsAddrs[0] = rc[k%2];
nengel@9 814 depsAddrs[1] = &sbe[k%bufs];
nengel@9 815 depsAddrs[2] = smbc;
nengel@9 816 depsAddrs[3] = &release;
nengel@7 817 taskID = VSs__create_taskID_of_size(2);
nengel@4 818 taskID[1] = 9;
nengel@5 819 taskID[2] = k;
nengel@9 820 VSs__submit_task_with_ID(&release_ref_list_taskType, &release_ref_list_task_args, depsAddrs, taskID);
nengel@2 821
nengel@3 822 output_taskArgs output_task_args;
nengel@3 823 output_task_args.h = h;
nengel@3 824 output_task_args.oc = oc;
nengel@3 825 output_task_args.sbe = &sbe[k%bufs];
nengel@9 826 depsAddrs = malloc(sizeof(void*) * output_taskType.numDeps);
nengel@9 827 /*sizeof(OutputContext), sizeof(SliceBufferEntry)*/
nengel@9 828 depsAddrs[0] = oc;
nengel@9 829 depsAddrs[1] = &sbe[k%bufs];
nengel@7 830 taskID = VSs__create_taskID_of_size(2);
nengel@4 831 taskID[1] = 10;
nengel@5 832 taskID[2] = k;
nengel@9 833 VSs__submit_task_with_ID(&output_taskType, &output_task_args, depsAddrs, taskID);
nengel@2 834 }
nengel@2 835
nengel@2 836 } else {
nengel@2 837 while(!pc->final_frame && frames++ < h->num_frames && !h->quit){
nengel@4 838
nengel@7 839 taskID = VSs__create_taskID_of_size(1);
nengel@3 840 taskID[1] = frames*10+1;
nengel@3 841 parse_taskArgs parse_task_args;
nengel@3 842 parse_task_args.h = h;
nengel@3 843 parse_task_args.pc = pc;
nengel@3 844 parse_task_args.nc = nc;
nengel@3 845 parse_task_args.sbe = &sbe[k%bufs];
nengel@9 846 depsAddrs = malloc(sizeof(void*) * parse_taskType.numDeps);
nengel@9 847 /*sizeof(ParserContext), sizeof(NalContext), sizeof(SliceBufferEntry)*/
nengel@9 848 depsAddrs[0] = pc;
nengel@9 849 depsAddrs[1] = nc;
nengel@9 850 depsAddrs[2] = &sbe[k%bufs];
nengel@9 851 VSs__submit_task_with_ID(&parse_taskType, &parse_task_args, depsAddrs, taskID);
nengel@2 852
nengel@7 853 taskID = VSs__create_taskID_of_size(1);
nengel@3 854 taskID[1] = frames*10+2;
nengel@3 855 decode_slice_entropy_taskArgs decode_slice_entropy_task_args;
nengel@3 856 decode_slice_entropy_task_args.h = h;
nengel@3 857 decode_slice_entropy_task_args.ec = ec[k%bufs];
nengel@3 858 decode_slice_entropy_task_args.sbe = &sbe[k%bufs];
nengel@9 859 depsAddrs = malloc(sizeof(void*) * decode_slice_entropy_taskType.numDeps);
nengel@9 860 /*sizeof(EntropyContext), sizeof(SliceBufferEntry)*/
nengel@9 861 depsAddrs[0] = ec[k%bufs];
nengel@9 862 depsAddrs[1] = &sbe[k%bufs];
nengel@9 863 VSs__submit_task_with_ID(&decode_slice_entropy_taskType, &decode_slice_entropy_task_args, depsAddrs, taskID);
nengel@2 864
nengel@7 865 taskID = VSs__create_taskID_of_size(1);
nengel@3 866 taskID[1] = frames*10+3;
nengel@3 867 decode_slice_mb_taskArgs decode_slice_mb_task_args;
nengel@3 868 decode_slice_mb_task_args.h = h;
nengel@3 869 decode_slice_mb_task_args.d = rc[0];
nengel@3 870 decode_slice_mb_task_args.sbe = &sbe[k%bufs];
nengel@9 871 depsAddrs = malloc(sizeof(void*) * decode_slice_mb_taskType.numDeps);
nengel@9 872 /*sizeof(MBRecContext), sizeof(SliceBufferEntry)*/
nengel@9 873 depsAddrs[0] = rc[0];
nengel@9 874 depsAddrs[1] = &sbe[k%bufs];
nengel@9 875 VSs__submit_task_with_ID(&decode_slice_mb_taskType, &decode_slice_mb_task_args, depsAddrs, taskID);
nengel@2 876
nengel@7 877 taskID = VSs__create_taskID_of_size(1);
nengel@3 878 taskID[1] = frames*10+4;
nengel@3 879 output_taskArgs output_task_args;
nengel@3 880 output_task_args.h = h;
nengel@3 881 output_task_args.oc = oc;
nengel@3 882 output_task_args.sbe = &sbe[k%bufs];
nengel@9 883 depsAddrs = malloc(sizeof(void*) * output_taskType.numDeps);
nengel@9 884 /*sizeof(OutputContext), sizeof(SliceBufferEntry)*/
nengel@9 885 depsAddrs[0] = oc;
nengel@9 886 depsAddrs[1] = &sbe[k%bufs];
nengel@9 887 VSs__submit_task_with_ID(&output_taskType, &output_task_args, depsAddrs, taskID);
nengel@3 888 //#pragma omp taskwait on(*pc)
nengel@7 889 VSs__taskwait_on(pc);
nengel@2 890 k++;
nengel@2 891 }
nengel@2 892 }
nengel@3 893 //#pragma omp taskwait
nengel@7 894 VSs__taskwait();
nengel@3 895
nengel@2 896 while ((out=output_frame(h, oc, NULL, h->ofile, h->frame_width, h->frame_height))) ;
nengel@2 897
nengel@6 898 //print_report(oc->frame_number, oc->video_size, 1, h->verbose);
nengel@2 899 h->num_frames = oc->frame_number;
nengel@2 900 /* finished ! */
nengel@2 901
nengel@2 902 free_parse_context(pc);
nengel@2 903 free_nal_context (nc);
nengel@2 904 free_output_context(oc);
nengel@2 905 for (int i=0; i<bufs; i++){
nengel@2 906 free_sb_entry(&sbe[i]);
nengel@2 907 free_entropy_context(ec[i]);
nengel@2 908 }
nengel@2 909 av_free(sbe);
nengel@2 910
nengel@2 911 for (int i=0; i<2; i++){
nengel@2 912 free_mbrec_context(rc[i]);
nengel@2 913 }
nengel@2 914
nengel@2 915 #if HAVE_LIBSDL2
nengel@2 916 if (h->display){
nengel@2 917 signal_sdl_exit(h);
nengel@2 918 pthread_join(sdl_thr, NULL);
nengel@2 919 }
nengel@2 920 #endif
nengel@2 921
nengel@7 922 return 0;
nengel@2 923 }