Ignore:
Timestamp:
Dec 16, 2015, 1:03:16 PM (9 years ago)
Author:
alain
Message:

Modify instrumentation to save results on virtual disk.

Location:
soft/giet_vm/applications/mjpeg
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/applications/mjpeg/demux.c

    r741 r748  
    3636
    3737// macro to use a shared TTY
    38 #define PRINTF(...)    lock_acquire( &tty_lock ); \
    39                        giet_tty_printf(__VA_ARGS__);  \
    40                        lock_release( &tty_lock );
     38#define PRINTF(...)  do { lock_acquire( &tty_lock ); \
     39                          giet_tty_printf(__VA_ARGS__);  \
     40                          lock_release( &tty_lock ); } while(0);
    4141
    4242///////////////////////////////////////////////////////////
    … …  
    8787
    8888    PRINTF("\n[MJPEG] thread DEMUX[%d] starts on P[%d,%d,%d] / trdid = %x\n",
    89            index , x , y , p, (uint32_t)trdid_demux[index] )
     89           index , x , y , p, (uint32_t)trdid_demux[index] );
    9090
    9191    // initialise BUFIO for MWMR channel <in>
    … …  
    9797#if (DEBUG_DEMUX > 1)
    9898if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    99 { PRINTF("\nDEMUX[%d] <in> : &mwmr = %x / &bufio = %x\n",
    100          index , mwmr_in , &bufio_in ) }
     99PRINTF("\nDEMUX[%d] <in> : &mwmr = %x / &bufio = %x\n",
     100         index , mwmr_in , &bufio_in );
    101101#endif
    102102
    … …  
    109109#if (DEBUG_DEMUX > 1)
    110110if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    111 { PRINTF("\nDEMUX[%d] : <out_quanti> : mwmr = %x / &bufio = %x\n",
    112          index , mwmr_out_quanti , &bufio_out_quanti ) }
     111PRINTF("\nDEMUX[%d] : <out_quanti> : mwmr = %x / &bufio = %x\n",
     112         index , mwmr_out_quanti , &bufio_out_quanti );
    113113#endif
    114114
    … …  
    121121#if (DEBUG_DEMUX > 1)
    122122if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    123 { PRINTF("\nDEMUX[%d] : <out_huff> : mwmr = %x / &bufio = %x\n",
    124          index , mwmr_out_huff , &bufio_out_huff ) }
     123PRINTF("\nDEMUX[%d] : <out_huff> : mwmr = %x / &bufio = %x\n",
     124         index , mwmr_out_huff , &bufio_out_huff );
    125125#endif
    126126
    … …  
    133133#if (DEBUG_DEMUX > 1)
    134134if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    135 { PRINTF("\nDEMUX[%d] : <out_data> : mwmr = %x / &bufio = %x\n",
    136          index , mwmr_out_data , &bufio_out_data ) }
     135PRINTF("\nDEMUX[%d] : <out_data> : mwmr = %x / &bufio = %x\n",
     136         index , mwmr_out_data , &bufio_out_data );
    137137#endif
    138138
    … …  
    160160#if (DEBUG_DEMUX > 1)
    161161if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    162 { PRINTF("\nDEMUX[%x] found Start of Image marker\n", index ) }
     162PRINTF("\nDEMUX[%x] found Start of Image marker\n", index );
    163163#endif
    164164
    … …  
    181181#if (DEBUG_DEMUX > 1)
    182182if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    183 { PRINTF("\nDEMUX[%x] found Start of Frame marker\n", index ) }
     183PRINTF("\nDEMUX[%x] found Start of Frame marker\n", index );
    184184#endif
    185185                // Only one component per image is supported
    … …  
    217217#if (DEBUG_DEMUX > 1)
    218218if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    219 { PRINTF("\nDEMUX[%x] found Quantization Table marker\n", index ) }
     219PRINTF("\nDEMUX[%x] found Quantization Table marker\n", index );
    220220#endif
    221221                // The  quantisation table segment being fixed length,
    … …  
    245245#if (DEBUG_DEMUX > 1)
    246246if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    247 { PRINTF("\nDEMUX[%x] found Huffman Table marker\n", index ) }
     247PRINTF("\nDEMUX[%x] found Huffman Table marker\n", index );
    248248#endif
    249249                // The Huffman Table segment being variable length,
    … …  
    290290#if (DEBUG_DEMUX > 1)
    291291if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    292 { PRINTF("\nDEMUX[%x] found Start of Scan marker\n", index ) }
     292PRINTF("\nDEMUX[%x] found Start of Scan marker\n", index );
    293293#endif
    294294                // The scan segment has a variable length:
    … …  
    342342#if (DEBUG_DEMUX > 1)
    343343if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    344 { PRINTF("\nDEMUX[%x] found End of Image marker\n", index ) }
     344PRINTF("\nDEMUX[%x] found End of Image marker\n", index );
    345345#endif
    346346                mwmr_bufio_flush( &bufio_out_data );
    … …  
    354354#if (DEBUG_DEMUX > 1)
    355355if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    356 { PRINTF("\nDEMUX[%x] found Comment or Application marker\n", index ) }
     356PRINTF("\nDEMUX[%x] found Comment or Application marker\n", index );
    357357#endif
    358358                // read segment length from bufio_in
    … …  
    381381#if DEBUG_DEMUX
    382382if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    383 { PRINTF("\nDEMUX[%d] completes image %d at cycle %d\n", index , image , giet_proctime() ) }
     383PRINTF("\nDEMUX[%d] completes image %d at cycle %d\n", index , image , giet_proctime() );
    384384#endif
    385385        image = image + x_size * y_size;

  • soft/giet_vm/applications/mjpeg/idct.c

    r736 r748  
    1919
    2020// macro to use a shared TTY
    21 #define PRINTF(...)   lock_acquire( &tty_lock ); \
    22                        giet_tty_printf(__VA_ARGS__);  \
    23                        lock_release( &tty_lock );
     21#define PRINTF(...) do { lock_acquire( &tty_lock ); \
     22                         giet_tty_printf(__VA_ARGS__);  \
     23                         lock_release( &tty_lock ); } while(0);
    2424
    2525// Useful constants
    … …  
    214214#if (DEBUG_IDCT > 1)
    215215if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    216  PRINTF("\nIDCT[%d] completes block %d/%d in image %d\n"
     216PRINTF("\nIDCT[%d] completes block %d/%d in image %d\n"
    217217         "  %x  %x  %x  %x  %x  %x  %x  %x\n"
    218218         "  %x  %x  %x  %x  %x  %x  %x  %x\n"
    … …  
    231231         bout[40], bout[41], bout[42], bout[43], bout[44], bout[45], bout[46], bout[47],
    232232         bout[48], bout[49], bout[50], bout[51], bout[52], bout[53], bout[54], bout[55],
    233          bout[56], bout[57], bout[58], bout[59], bout[60], bout[61], bout[62], bout[63]) }
     233         bout[56], bout[57], bout[58], bout[59], bout[60], bout[61], bout[62], bout[63]);
    234234}
    235235#endif
    … …  
    238238#if DEBUG_IDCT
    239239if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    240 { PRINTF("\nIDCT[%d] completes image %d at cycle %d\n", index , image , giet_proctime() ) }
     240PRINTF("\nIDCT[%d] completes image %d at cycle %d\n", index , image , giet_proctime() );
    241241#endif
    242242

  • soft/giet_vm/applications/mjpeg/iqzz.c

    r736 r748  
    1313
    1414// macro to use a shared TTY
    15 #define PRINTF(...)   lock_acquire( &tty_lock ); \
    16                        giet_tty_printf(__VA_ARGS__);  \
    17                        lock_release( &tty_lock );
     15#define PRINTF(...) do { lock_acquire( &tty_lock ); \
     16                         giet_tty_printf(__VA_ARGS__);  \
     17                         lock_release( &tty_lock ); } while(0);
    1818
    1919//////////////////////////////////////////////////////////////
    … …  
    5656
    5757    PRINTF("\n[MJPEG] thread IQZZ[%d] starts on P[%d,%d,%d] / trdid = %x\n",
    58            index , x , y , p, (uint32_t)trdid_iqzz[index] )
     58           index , x , y , p, (uint32_t)trdid_iqzz[index] );
    5959
    6060
    … …  
    6868#if (DEBUG_IQZZ > 1)
    6969if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    70 { PRINTF("\nIQZZ[%d] get quantisation coefs for image %d\n"
     70PRINTF("\nIQZZ[%d] get quantisation coefs for image %d\n"
    7171         "%d  %d  %d  %d  %d  %d  %d  %d\n"
    7272         "%d  %d  %d  %d  %d  %d  %d  %d\n"
    … …  
    8585         QT[40],QT[41],QT[42],QT[43],QT[44],QT[45],QT[46],QT[47],
    8686         QT[48],QT[49],QT[50],QT[51],QT[52],QT[53],QT[54],QT[55],
    87          QT[56],QT[57],QT[58],QT[59],QT[60],QT[61],QT[62],QT[63] ) }
     87         QT[56],QT[57],QT[58],QT[59],QT[60],QT[61],QT[62],QT[63] );
    8888#endif
    8989
    … …  
    104104#if (DEBUG_IQZZ > 1)
    105105if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    106 { PRINTF("\nIQZZ[%d] completes block %d/%d in image %d\n"
     106PRINTF("\nIQZZ[%d] completes block %d/%d in image %d\n"
    107107         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
    108108         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
    … …  
    121121         bout[40], bout[41], bout[42], bout[43], bout[44], bout[45], bout[46], bout[47],
    122122         bout[48], bout[49], bout[50], bout[51], bout[52], bout[53], bout[54], bout[55],
    123          bout[56], bout[57], bout[58], bout[59], bout[60], bout[61], bout[62], bout[63]) }
     123         bout[56], bout[57], bout[58], bout[59], bout[60], bout[61], bout[62], bout[63]);
    124124#endif
    125125        }  // end for blocks
    … …  
    127127#if DEBUG_IQZZ
    128128if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    129 { PRINTF("\nIQZZ[%d] completes image %d at cycle %d\n", index , image , giet_proctime() ) }
     129PRINTF("\nIQZZ[%d] completes image %d at cycle %d\n", index , image , giet_proctime() );
    130130#endif
    131131

  • soft/giet_vm/applications/mjpeg/libu.c

    r736 r748  
    2323
    2424// macro to use a shared TTY
    25 #define PRINTF(...)   lock_acquire( &tty_lock ); \
    26                        giet_tty_printf(__VA_ARGS__);  \
    27                        lock_release( &tty_lock );
     25#define PRINTF(...) do { lock_acquire( &tty_lock ); \
     26                         giet_tty_printf(__VA_ARGS__);  \
     27                         lock_release( &tty_lock ); } while(0);
    2828
    2929//////////////////////////////////////////////////////////////
    … …  
    5353
    5454    PRINTF("\n[MJPEG] thread LIBU[%d] starts on P[%d,%d,%d] / trdid = %x\n",
    55            index , x , y , p, (uint32_t)trdid_libu[index] )
     55           index , x , y , p, (uint32_t)trdid_libu[index] );
    5656
    5757    uint32_t image = index;
    … …  
    8585#if (DEBUG_LIBU > 1)
    8686if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    87 { PRINTF("\nLIBU[%d] copy block[%d] for image %d\n",
    88          index, line * nblocks_w + column , image ) }
     87PRINTF("\nLIBU[%d] copy block[%d] for image %d\n",
     88         index, line * nblocks_w + column , image );
    8989#endif
    9090            }
    … …  
    100100#if DEBUG_LIBU
    101101if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    102 { PRINTF("\nLIBU[%d] completes image %d at cycle %d\n", index , image , time ) }
     102PRINTF("\nLIBU[%d] completes image %d at cycle %d\n", index , image , time );
    103103#endif
    104104        // register date of display for instrumentation

  • soft/giet_vm/applications/mjpeg/mjpeg.c

    r741 r748  
    3131
    3232// macro to use a shared TTY
    33 #define PRINTF(...)    lock_acquire( &tty_lock ); \
    34                        giet_tty_printf(__VA_ARGS__);  \
    35                        lock_release( &tty_lock );
     33#define PRINTF(...)    do { lock_acquire( &tty_lock ); \
     34                            giet_tty_printf(__VA_ARGS__);  \
     35                            lock_release( &tty_lock ); } while(0);
    3636
    3737///////////////////////////////////////////////
    … …  
    125125    if ( INTERACTIVE_MODE )
    126126    {
    127         PRINTF("\n[MJPEG] enter path for JPEG stream file (default is plan_48.mjpg)\n> ") 
     127        PRINTF("\n[MJPEG] enter path for JPEG stream file (default is plan_48.mjpg)\n> ");
    128128        giet_tty_gets( file_pathname , 256 );
    129129
    … …  
    136136        else
    137137        {
    138             PRINTF("\n[MJPEG] enter image width\n> ") 
     138            PRINTF("\n[MJPEG] enter image width\n> ");
    139139            giet_tty_getw( &image_width );
    140             PRINTF("\n[MJPEG] enter image height\n> ") 
     140            PRINTF("\n[MJPEG] enter image height\n> "); 
    141141            giet_tty_getw( &image_height );
    142             PRINTF("\n") 
     142            PRINTF("\n");
    143143        }
    144144    }
    … …  
    154154 
    155155    if ( USE_DCT_COPROC )
    156     { PRINTF("\n\n[MJPEG] stream %s / %d clusters / %d cores / DCT COPROC\n\n",
    157            file_pathname , x_size*y_size , nprocs ) }
     156    {
     157        PRINTF("\n\n[MJPEG] stream %s / %d clusters / %d cores / DCT COPROC\n\n",
     158               file_pathname , x_size*y_size , nprocs );
     159    }
    158160    else
    159     { PRINTF("\n\n[MJPEG] stream %s / %d clusters / %d cores / NO DCT COPROC\n\n",
    160            file_pathname , x_size*y_size , nprocs ) }
     161    {
     162        PRINTF("\n\n[MJPEG] stream %s / %d clusters / %d cores / NO DCT COPROC\n\n",
     163               file_pathname , x_size*y_size , nprocs );
     164    }
    161165
    162166    // compute nblocks_h & nblocks_w
    … …  
    234238        pc = main_2_demux[n];
    235239        PRINTF(" - main_2_demux[%d]  = %x / &lock = %x / &buf = %x / size = %d\n",
    236                n, pc, (uint32_t)&pc->lock, (uint32_t)pc->data, pc->depth<<2 ) 
     240               n, pc, (uint32_t)&pc->lock, (uint32_t)pc->data, pc->depth<<2 );
    237241
    238242        pc = demux_2_vld_data[n];
    239243        PRINTF(" - demux_2_vld[%d] = %x / &lock = %x / &buf = %x / size = %d\n",
    240                n, pc, (uint32_t)&pc->lock, (uint32_t)pc->data, pc->depth<<2 ) 
     244               n, pc, (uint32_t)&pc->lock, (uint32_t)pc->data, pc->depth<<2 );
    241245
    242246        pc = vld_2_iqzz[n];
    243247        PRINTF(" - vld_2_iqzz[%d]  = %x / &lock = %x / &buf = %x / size = %d\n",
    244                n, pc, (uint32_t)&pc->lock, (uint32_t)pc->data, pc->depth<<2 ) 
     248               n, pc, (uint32_t)&pc->lock, (uint32_t)pc->data, pc->depth<<2 );
    245249
    246250        pc = iqzz_2_idct[n];
    247251        PRINTF(" - iqzz_2_idct[%d] = %x / &lock = %x / &buf = %x / size = %d\n",
    248                n, pc, (uint32_t)&pc->lock, (uint32_t)pc->data, pc->depth<<2 ) 
     252               n, pc, (uint32_t)&pc->lock, (uint32_t)pc->data, pc->depth<<2 );
    249253
    250254        pc = idct_2_libu[n];
    251255        PRINTF(" - idct_2_libu[%d] = %x / &lock = %x / &buf = %x / size = %d\n",
    252                n, pc, (uint32_t)&pc->lock, (uint32_t)pc->data, pc->depth<<2 ) 
     256               n, pc, (uint32_t)&pc->lock, (uint32_t)pc->data, pc->depth<<2 );
    253257    }
    254258
    … …  
    407411#if DEBUG_MAIN
    408412PRINTF("\nMAIN send image %d to cluster %d at cycle %d : %d bytes\n",
    409        image , cluster , giet_proctime() , bytes_count )
     413       image , cluster , giet_proctime() , bytes_count );
    410414#endif
    411415        // increment image index
    … …  
    429433
    430434            if ( giet_pthread_join( trdid_demux[index] , NULL ) )
    431             { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for demux[%d]\n", index ) }
     435            PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for demux[%d]\n", index );
    432436
    433437            if ( giet_pthread_join( trdid_vld[index] , NULL ) )
    434             { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for vld[%d]\n", index ) }
     438            PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for vld[%d]\n", index );
    435439
    436440            if ( giet_pthread_join( trdid_iqzz[index] , NULL ) )
    437             { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for iqzz[%d]\n", index ) }
     441            PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for iqzz[%d]\n", index );
    438442
    439443            if ( USE_DCT_COPROC == 0 )
    440444            {
    441445                if ( giet_pthread_join( trdid_idct[index] , NULL ) )
    442                 { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for idct[%d]\n", index ) }
     446                PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for idct[%d]\n", index );
    443447            }
    444448
    445449            if ( giet_pthread_join( trdid_libu[index] , NULL ) )
    446             { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for libu[%d]\n", index ) }
     450            PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for libu[%d]\n", index );
    447451
    448452            if ( USE_DCT_COPROC )
    … …  
    459463    /////////////////////////////////////////////////////////////////////////////////////
    460464
    461     PRINTF("\n[MJPEG] Instumentation Results\n" )
     465    // display on TTY
     466    PRINTF("\n[MJPEG] Instumentation Results\n" );
    462467    for ( image = 0 ; image < MAX_IMAGES ; image++ )
    463     { PRINTF(" - Image %d : completed at cycle %d\n", image , date[image]) }
    464 
     468    PRINTF(" - Image %d : completed at cycle %d\n", image , date[image]);
     469
     470    // save on disk
     471    unsigned int fdout = giet_fat_open( "/home/mjpeg_instrumentation" , O_CREATE );
     472    if ( fdout < 0 )
     473    PRINTF("\n[MJPEG ERROR] cannot open file /home/mjpeg_instrumentation\n");
     474
     475    int ret = giet_fat_lseek( fdout, 0 , SEEK_END );
     476    if( ret < 0 )
     477    PRINTF("\n[MJPEG ERROR] cannot seek file /home/mjpeg_instrumentation\n");
     478
     479    if( USE_DCT_COPROC )
     480    {
     481        giet_fat_fprintf( fdout, "\n*** stream %s / %d clusters / %d cores / DCT COPROC\n",
     482                          file_pathname , x_size*y_size , nprocs );
     483    }
     484    else
     485    {
     486        giet_fat_fprintf( fdout, "stream %s / %d clusters / %d cores / NO DCT COPROC\n\n",
     487                          file_pathname , x_size*y_size , nprocs );
     488    }
     489    for ( image = 0 ; image < MAX_IMAGES ; image++ )
     490    {
     491        giet_fat_fprintf( fdout, " - Image %d : completed at cycle %d\n",
     492                          image , date[image]);
     493    }
     494
     495    // completed
    465496    giet_pthread_exit( "main completed" );
    466497   

  • soft/giet_vm/applications/mjpeg/mjpeg.h

    r741 r748  
    2020////////////////////////////////////////////////////////////////////////////////////////
    2121
    22 #define   MAX_IMAGES         16
     22#define   MAX_IMAGES         2
    2323
    2424#define   USE_DCT_COPROC     1

  • soft/giet_vm/applications/mjpeg/vld.c

    r736 r748  
    2323
    2424// macro to use a shared TTY
    25 #define PRINTF(...)    lock_acquire( &tty_lock ); \
    26                        giet_tty_printf(__VA_ARGS__);  \
    27                        lock_release( &tty_lock );
     25#define PRINTF(...)  do { lock_acquire( &tty_lock ); \
     26                          giet_tty_printf(__VA_ARGS__);  \
     27                          lock_release( &tty_lock ); } while(0);
    2828
    2929////////////////////////////////////////////////////////////////////////////////////////
    … …  
    166166    uint32_t type = ( is_ac ) ? 1 : 0;
    167167
    168     if ( is_ac ) { PRINTF("\n AC Huffman Table\n\n") }
    169     else         { PRINTF("\n DC Huffman Table\n\n") }
     168    if ( is_ac )
     169    {
     170        PRINTF("\n AC Huffman Table\n\n");
     171    }
     172    else
     173    {
     174        PRINTF("\n DC Huffman Table\n\n");
     175    }
    170176
    171177    for ( j = 0; j < 16; j++ ) // j = code_length - 1
    172178    {
    173179        PRINTF(" length = %d / mincode = %x / maxcode = %x / valptr = %d\n",
    174         j+1 , huff->MinCode[type][j] , huff->MaxCode[type][j] , huff->ValPtr[type][j] )
    175     }
    176 
    177     PRINTF("\n")
     180        j+1 , huff->MinCode[type][j] , huff->MaxCode[type][j] , huff->ValPtr[type][j]);
     181    }
     182
     183    PRINTF("\n");
    178184
    179185    for ( j = 0 ; j < 16 ; j++ )  // j == code_length - 1
    … …  
    186192
    187193            PRINTF(" Symbol[%d] = %x / code[%d] = %x\n",
    188             index , huff->HT[type][index] , index , code )
     194            index , huff->HT[type][index] , index , code );
    189195        }
    190196    }
    191197 
    192     PRINTF("\n")
     198    PRINTF("\n");
    193199}
    194200
    … …  
    342348#if (DEBUG_VLD > 2)
    343349if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    344 { PRINTF("\nVLD[%d] : DC[0] = %d / reformat( %x , %d ) = %d\n",
    345          index , buf[0], temp , symbol , value ) }
     350PRINTF("\nVLD[%d] : DC[0] = %d / reformat( %x , %d ) = %d\n",
     351         index , buf[0], temp , symbol , value );
    346352#endif
    347353
    … …  
    357363#if (DEBUG_VLD > 2)
    358364if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    359 { PRINTF("\nVLD[%d] : EOB found at i = %d\n", index , i ) }
     365PRINTF("\nVLD[%d] : EOB found at i = %d\n", index , i );
    360366#endif
    361367            break;
    … …  
    379385#if (DEBUG_VLD > 2)
    380386if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    381 { PRINTF("\nVLD[%d] : AC[%d] = %d / reformat( %x , %d ) = %d\n",
    382          index , i , buf[i] , temp , cat , value ) }
     387PRINTF("\nVLD[%d] : AC[%d] = %d / reformat( %x , %d ) = %d\n",
     388         index , i , buf[i] , temp , cat , value );
    383389#endif
    384390
    … …  
    390396#if (DEBUG_VLD > 1 )
    391397if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    392 { PRINTF("\nVLD[%d] completes block %d/%d in image %d\n"
     398PRINTF("\nVLD[%d] completes block %d/%d in image %d\n"
    393399         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
    394400         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
    … …  
    407413         buf[40], buf[41], buf[42], buf[43], buf[44], buf[45], buf[46], buf[47],
    408414         buf[48], buf[49], buf[50], buf[51], buf[52], buf[53], buf[54], buf[55],
    409          buf[56], buf[57], buf[58], buf[59], buf[60], buf[61], buf[62], buf[63]) }
     415         buf[56], buf[57], buf[58], buf[59], buf[60], buf[61], buf[62], buf[63]);
    410416#endif
    411417
    … …  
    442448
    443449    PRINTF("\n[MJPEG] thread VLD[%d] starts on P[%d,%d,%d] / trdid = %x\n",
    444            index , x , y , p, (uint32_t)trdid_vld[index] )
     450           index , x , y , p, (uint32_t)trdid_vld[index] );
    445451
    446452
    … …  
    452458#if (DEBUG_VLD > 1)
    453459if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    454 { PRINTF("\nVLD[%d] <in_data> : &mwmr = %x / &bufio = %x\n",
    455          index , mwmr_in_data , &bufio_in_data ) }
     460PRINTF("\nVLD[%d] <in_data> : &mwmr = %x / &bufio = %x\n",
     461         index , mwmr_in_data , &bufio_in_data );
    456462#endif
    457463
    … …  
    463469#if (DEBUG_VLD > 1)
    464470if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    465 { PRINTF("\nVLD[%d] <in_huff> : &mwmr = %x / &bufio = %x\n",
     471PRINTF("\nVLD[%d] <in_huff> : &mwmr = %x / &bufio = %x\n",
    466472         index , mwmr_in_huff , &bufio_in_huff ) }
    467473#endif
    … …  
    483489#if (DEBUG_VLD > 1)
    484490if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    485 { PRINTF("\nVLD[%d] load Huffman tables for image %d\n", index , image ) }
     491PRINTF("\nVLD[%d] load Huffman tables for image %d\n", index , image );
    486492#endif
    487493
    … …  
    501507#if (DEBUG_VLD > 1)
    502508if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    503 { PRINTF("\nVLD[%d] uncompress block %d/%d in image %d\n", index, block, nblocks, image ) }
     509PRINTF("\nVLD[%d] uncompress block %d/%d in image %d\n", index, block, nblocks, image );
    504510#endif
    505511            prev_dc = vld_unpack_block( index,
    … …  
    514520#if DEBUG_VLD
    515521if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
    516 { PRINTF("\nVLD[%d] completes image %d at cycle %d\n", index , image , giet_proctime() ) }
     522PRINTF("\nVLD[%d] completes image %d at cycle %d\n", index , image , giet_proctime() );
    517523#endif
    518524        image = image + x_size*y_size;
Note: See TracChangeset for help on using the changeset viewer.