source: soft/giet_vm/applications/mjpeg/mjpeg.c @ 747

Last change on this file since 747 was 741, checked in by alain, 9 years ago

Remove the TG thread: The mjpeg strem dispatch is
directly done by the main thread.

File size: 18.4 KB
Line 
1/////////////////////////////////////////////////////////////////////////////////////////
2// File   : mjpeg.c   
3// Date   : octobre 2015
4// author : Alain Greiner
5/////////////////////////////////////////////////////////////////////////////////////////
6// This multi-threaded application illustrates "pipe-line" parallelism, and message
7// passing programming model, on top of the POSIX threads API.
8// It makes the parallel decompression of a MJPEG bitstream contained in a file.
9// The application is described as a TCG (Task and Communication Graph), and all
10// communications between threads uses MWMR channels,.
11// It uses the chained buffer DMA component to display the images on the graphic display.
12// It contains 5 types of threads, plus the "main" thread, that makes initialisation,
13// dispatch the byte stream to the various pipelines, and makes instrumentation.
14// and 7 types of MWMR communication channels:
15// - the main thread is only mapped in cluster[0,0], but all other threads
16//   (DEMUX, VLD, IQZZ, IDCT, LIBU) are replicated in all clusters.
17// - all MWMR channels are replicated in all clusters.
18// The number of cluster cannot be larger than 16*16.
19// The number of processors per cluster is not constrained.
20// The frame buffer size must fit the decompressed images size.
21// It uses one TTY terminal shared by all tasks.
22/////////////////////////////////////////////////////////////////////////////////////////
23
24#include <stdio.h>
25#include <mwmr_channel.h>
26#include <malloc.h>
27#include <stdlib.h>
28#include "mjpeg.h"
29#include <mapping_info.h>     // for coprocessor types and modes
30
31
32// macro to use a shared TTY
33#define PRINTF(...)    lock_acquire( &tty_lock ); \
34                       giet_tty_printf(__VA_ARGS__);  \
35                       lock_release( &tty_lock );
36
37///////////////////////////////////////////////
38//       Global variables
39///////////////////////////////////////////////
40
41uint32_t         fd;    // file descriptor for the file containing the MJPEG stream
42
43// arrays of pointers on MWMR channels
44mwmr_channel_t*  main_2_demux[256];       // one per cluster
45mwmr_channel_t*  demux_2_vld_data[256];   // one per cluster
46mwmr_channel_t*  demux_2_vld_huff[256];   // one per cluster
47mwmr_channel_t*  demux_2_iqzz[256];       // one per cluster
48mwmr_channel_t*  vld_2_iqzz[256];         // one per cluster
49mwmr_channel_t*  iqzz_2_idct[256];        // one per cluster
50mwmr_channel_t*  idct_2_libu[256];        // one per cluster
51
52// thread trdid ( for pthread_create() and pthread_join() )
53pthread_t   trdid_demux[256];             // one per cluster
54pthread_t   trdid_vld[256];               // one per cluster
55pthread_t   trdid_iqzz[256];              // one per cluster
56pthread_t   trdid_idct[256];              // one per cluster
57pthread_t   trdid_libu[256];              // one per cluster
58
59user_lock_t      tty_lock;                // lock protecting shared TTY
60
61uint8_t*         cma_buf[256];            // CMA buffers (one per cluster)
62void*            cma_sts[256];            // CMA buffers status
63
64uint32_t         fbf_width;               // Frame Buffer width
65uint32_t         fbf_height;              // Frame Buffer height
66
67uint32_t         nblocks_h;               // number of blocks in a column
68uint32_t         nblocks_w;               // number of blocks in a row   
69
70uint32_t         date[MAX_IMAGES];        // date of libu completion
71
72////////////////////////////////////////////////
73// declare thread functions
74////////////////////////////////////////////////
75
76extern void demux( uint32_t index );
77extern void vld( uint32_t index );
78extern void iqzz( uint32_t index );
79extern void idct( uint32_t index );
80extern void libu( uint32_t index );
81
82/////////////////////////////////////////
83__attribute__ ((constructor)) void main()
84/////////////////////////////////////////
85{
86    // get platform parameters
87    uint32_t  x_size;
88    uint32_t  y_size;
89    uint32_t  nprocs;
90    giet_procs_number( &x_size , &y_size , &nprocs );
91
92    // shared TTY allocation
93    giet_tty_alloc( 1 );
94    lock_init( &tty_lock );
95
96    // check platform parameters
97    giet_pthread_assert( (nprocs <= 6),
98                         "[MJPEG ERROR] nprocs cannot be larger than 4");
99
100    giet_pthread_assert( (x_size <= 16),
101                         "[MJPEG ERROR] x_size cannot be larger than 16");
102
103    giet_pthread_assert( (y_size <= 16),
104                         "[MJPEG ERROR] y_size cannot be larger than 16");
105
106    giet_pthread_assert( (MAX_IMAGES >= (x_size*y_size)),
107                         "MJPEG ERROR] number of images smaller than x_size * y_size");
108
109    // check frame buffer size
110    giet_fbf_size( &fbf_width , &fbf_height );
111
112    giet_pthread_assert( ((fbf_width & 0x7) == 0) && ((fbf_height & 0x7) == 0) ,
113                         "[MJPEG ERROR] image width and height must be multiple of 8");
114
115    // request frame buffer and CMA channel allocation
116    giet_fbf_alloc();
117    giet_fbf_cma_alloc( x_size * y_size );
118
119    // file name and image size acquisition
120    char          file_pathname[256];
121    uint32_t      image_width;
122    uint32_t      image_height;
123    uint32_t      fd;                   // file descriptor
124
125    if ( INTERACTIVE_MODE )
126    {
127        PRINTF("\n[MJPEG] enter path for JPEG stream file (default is plan_48.mjpg)\n> ") 
128        giet_tty_gets( file_pathname , 256 );
129
130        if ( file_pathname[0] == 0 )
131        {
132            strcpy( file_pathname , "/misc/plan_48.mjpg" );
133            image_width  = 48;
134            image_height = 48;
135        }
136        else
137        {
138            PRINTF("\n[MJPEG] enter image width\n> ") 
139            giet_tty_getw( &image_width );
140            PRINTF("\n[MJPEG] enter image height\n> ") 
141            giet_tty_getw( &image_height );
142            PRINTF("\n") 
143        }
144    }
145    else
146    {
147        strcpy( file_pathname , "/misc/plan_48.mjpg" );
148        image_width  = 48;
149        image_height = 48;
150    }
151   
152    giet_pthread_assert( (image_width == fbf_width) && (image_height == fbf_height) ,
153                         "[MJPEG ERROR] image size doesn't fit frame buffer size");
154 
155    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 ) }
158    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    // compute nblocks_h & nblocks_w
163    nblocks_w = fbf_width / 8;
164    nblocks_h = fbf_height / 8;
165
166    // open file containing the MJPEG bit stream
167    fd = giet_fat_open( file_pathname , 0 );
168
169    giet_pthread_assert( (fd >= 0),
170                         "[MJPEG ERROR] cannot open MJPEG stream file");
171
172    // index for loops
173    uint32_t x;
174    uint32_t y;
175    uint32_t n;
176
177    uint32_t*  buffer; 
178
179    // initialise distributed heap,
180    // allocate MWMR channels
181    // allocate buffers for CMA
182    for ( x = 0 ; x < x_size ; x++ ) 
183    {
184        for ( y = 0 ; y < y_size ; y++ ) 
185        {
186            uint32_t index = x*y_size + y;
187
188            // initialise heap[x][y]
189            heap_init( x , y );
190
191            // allocate MWMR channels in cluster[x][y]
192            main_2_demux[index]     = remote_malloc( sizeof( mwmr_channel_t ) , x , y );
193            buffer                  = remote_malloc( 4 * MAIN_2_DEMUX_DEPTH , x , y );
194            mwmr_init( main_2_demux[index] , buffer , 1 , MAIN_2_DEMUX_DEPTH );
195
196            demux_2_vld_data[index] = remote_malloc( sizeof( mwmr_channel_t ) , x , y );
197            buffer                  = remote_malloc( 4 * DEMUX_2_VLD_DATA_DEPTH , x , y );
198            mwmr_init( demux_2_vld_data[index] , buffer , 1 , DEMUX_2_VLD_DATA_DEPTH );
199
200            demux_2_vld_huff[index] = remote_malloc( sizeof( mwmr_channel_t ) , x , y );
201            buffer                  = remote_malloc( 4 * DEMUX_2_VLD_HUFF_DEPTH , x , y );
202            mwmr_init( demux_2_vld_huff[index] , buffer , 1 , DEMUX_2_VLD_HUFF_DEPTH );
203
204            demux_2_iqzz[index]     = remote_malloc( sizeof( mwmr_channel_t ) , x , y );
205            buffer                  = remote_malloc( 4 * DEMUX_2_IQZZ_DEPTH , x , y );
206            mwmr_init( demux_2_iqzz[index] , buffer , 1 , DEMUX_2_IQZZ_DEPTH );
207
208            vld_2_iqzz[index]       = remote_malloc( sizeof( mwmr_channel_t ) , x , y );
209            buffer                  = remote_malloc( 4 * VLD_2_IQZZ_DEPTH , x , y );
210            mwmr_init( vld_2_iqzz[index] , buffer , 1 , VLD_2_IQZZ_DEPTH );
211
212            iqzz_2_idct[index]      = remote_malloc( sizeof( mwmr_channel_t ) , x , y );
213            buffer                  = remote_malloc( 4 * IQZZ_2_IDCT_DEPTH , x , y );
214            mwmr_init( iqzz_2_idct[index] , buffer , 1 , IQZZ_2_IDCT_DEPTH );
215
216            idct_2_libu[index]      = remote_malloc( sizeof( mwmr_channel_t ) , x , y );
217            buffer                  = remote_malloc( 4 * IDCT_2_LIBU_DEPTH , x , y );
218            mwmr_init( idct_2_libu[index] , buffer , 1 , IDCT_2_LIBU_DEPTH );
219
220            // allocate and register CMA buffers in cluster[x][y]
221            cma_buf[index] = remote_malloc( fbf_width * fbf_height , x , y );
222            cma_sts[index] = remote_malloc( 64 , x , y );
223            giet_fbf_cma_init_buf( index , cma_buf[index] , cma_sts[index] );
224        }
225    }
226
227    // start CMA channel
228    giet_fbf_cma_start();
229
230    mwmr_channel_t* pc;
231
232    for ( n = 0 ; n < x_size*y_size ; n++ )
233    {
234        pc = main_2_demux[n];
235        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 ) 
237
238        pc = demux_2_vld_data[n];
239        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 ) 
241
242        pc = vld_2_iqzz[n];
243        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 ) 
245
246        pc = iqzz_2_idct[n];
247        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 ) 
249
250        pc = idct_2_libu[n];
251        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 ) 
253    }
254
255    // launch all threads : precise mapping is defined in the mjpeg.py file
256    uint32_t index;
257
258    for ( x = 0 ; x < x_size ; x++ )
259    {
260        for ( y = 0 ; y < y_size ; y++ )
261        {
262            index = x * y_size + y;
263
264            // DEMUX 
265            if ( giet_pthread_create( &trdid_demux[index], NULL, &demux , (void*)index ) )
266            giet_pthread_exit( "error launching thread demux\n");
267
268            // VLD
269            if ( giet_pthread_create( &trdid_vld[index], NULL, &vld , (void*)index ) )
270            giet_pthread_exit( "error launching thread vld\n");
271
272            // IQZZ
273            if ( giet_pthread_create( &trdid_iqzz[index], NULL, &iqzz , (void*)index ) )
274            giet_pthread_exit( "error launching thread iqzz");
275
276            // IDCT
277            if ( USE_DCT_COPROC )  // allocate, initialise, and start hardware coprocessor
278            {
279                giet_coproc_channel_t in_channel;
280                giet_coproc_channel_t out_channel;
281                uint32_t  cluster_xy  = (x<<4) + y;
282                uint32_t  coproc_type = 2;
283                uint32_t  info;
284
285                // allocate DCT coprocessor
286                giet_coproc_alloc( cluster_xy , coproc_type , &info );
287
288                // initialize channels
289                in_channel.channel_mode = MODE_MWMR;
290                in_channel.buffer_size  = (iqzz_2_idct[index]->depth)<<2;
291                in_channel.buffer_vaddr = (uint32_t)(iqzz_2_idct[index]->data);
292                in_channel.status_vaddr = (uint32_t)(&iqzz_2_idct[index]->sts);
293                in_channel.lock_vaddr   = (uint32_t)(&iqzz_2_idct[index]->lock);
294   
295                giet_coproc_channel_init( cluster_xy , coproc_type , 0 , &in_channel );
296
297                out_channel.channel_mode = MODE_MWMR;
298                out_channel.buffer_size  = (idct_2_libu[index]->depth)<<2;
299                out_channel.buffer_vaddr = (uint32_t)(idct_2_libu[index]->data);
300                out_channel.status_vaddr = (uint32_t)(&idct_2_libu[index]->sts);
301                out_channel.lock_vaddr   = (uint32_t)(&idct_2_libu[index]->lock);
302
303                giet_coproc_channel_init( cluster_xy , coproc_type , 1 , &out_channel );
304
305                // start coprocessor
306                giet_coproc_run( cluster_xy , coproc_type );
307            }
308            else                   // launches a software thread
309            {
310                if ( giet_pthread_create( &trdid_idct[index], NULL, &idct , (void*)index ) )
311                giet_pthread_exit( "error launching thread idct\n");
312            }
313
314            // LIBU
315            if ( giet_pthread_create( &trdid_libu[index], NULL, &libu , (void*)index ) )
316            giet_pthread_exit( "error launching thread libu\n");
317        }
318    }
319
320    /////////////////////////////////////////////////////////////////////////////////////
321    // dispatch the byte stream to the demux threads, one compressed image per cluster.
322    // It transfer the stream from the file identified by the fd argument to a 1024
323    // bytes local buffer. It analyses the stream to detect the End_of_Image markers.
324    // All the bytes corresponding to a single image from the first byte, to the EOI
325    // marker included, are written in the main_2_demux[index] channel, in increasing
326    // order of the cluster index.
327    /////////////////////////////////////////////////////////////////////////////////////
328
329    // allocate input buffer : 1024 bytes
330    uint8_t        bufin[1024];
331
332    // allocate output bufio to access output MWMR channels : 64 bytes == 16 words
333    mwmr_bufio_t  bufio;
334    uint8_t       bufout[64]; 
335    mwmr_bufio_init( &bufio , bufout , 64 , 0 , main_2_demux[0] );
336
337    uint32_t  image;           // image index
338    uint32_t  cluster;         // cluster index / modulo x_size*y_size
339    uint32_t  ptr;             // byte pointer in input buffer
340    uint32_t  eoi_found;       // boolean : End-of-Image found
341    uint32_t  ff_found;        // boolean : 0xFF value found
342    uint32_t  bytes_count;     // mumber of bytes in compressed image
343       
344    // initialise image and cluster index, and bufin pointer
345    image   = 0;
346    cluster = 0;
347    ptr     = 0;
348
349    while( image < MAX_IMAGES )  // one compressed image per iteration
350    {
351        // initialise image specific variables
352        eoi_found   = 0;
353        ff_found    = 0;
354        bytes_count = 0; 
355       
356        // re-initialise the destination buffer for each image
357        bufio.mwmr = main_2_demux[cluster];
358
359        // scan bit stream until EOI found
360        // transfer one byte per iteration from input buffer to output bufio
361        while ( eoi_found == 0 )
362        {
363            // - tranfer 1024 bytes from file to input buffer when input buffer empty.
364            // - return to first byte in input file when EOF found,
365            //   to emulate an infinite stream of images.
366            if ( ptr == 0 )
367            {
368                uint32_t r = giet_fat_read( fd , bufin , 1024 );
369                if ( r < 1024 ) 
370                {
371                    giet_fat_lseek( fd , 0 , SEEK_SET );
372                    giet_fat_read( fd , bufin + r , 1024 - r );
373                }
374            }
375
376            // transfer one byte from input buffer to output bufio
377            mwmr_bufio_write_byte( &bufio , bufin[ptr] );
378
379            // analyse this byte to find EOI marker OxFFD8
380            // flush the output buffer when EOI found
381            if ( ff_found )  // possible End of Image
382            { 
383                ff_found = 0;
384                if ( bufin[ptr] == 0xD9 )   // End of Image found
385                {
386                    // exit current image
387                    eoi_found = 1;
388
389                    // flush output bufio
390                    mwmr_bufio_flush( &bufio );
391                }
392            }
393            else           // test if first byte of a marker
394            {
395                if ( bufin[ptr] == 0xFF )  ff_found = 1;
396            }       
397
398            // increment input buffer pointer modulo 1024
399            ptr++;
400            if ( ptr == 1024 ) ptr = 0;
401               
402            // increment bytes_count for current image
403            bytes_count++;
404
405        } // end while (eoi)
406 
407#if DEBUG_MAIN
408PRINTF("\nMAIN send image %d to cluster %d at cycle %d : %d bytes\n",
409       image , cluster , giet_proctime() , bytes_count )
410#endif
411        // increment image index
412        image++;
413
414        // increment cluster index modulo (x_size*y_size)   
415        cluster++; 
416        if (cluster == x_size * y_size) cluster = 0;   
417
418    } // end while on images
419
420    /////////////////////////////////////////////////////////////////////////////////////
421    // wait all threads completion
422    /////////////////////////////////////////////////////////////////////////////////////
423
424    for ( x = 0 ; x < x_size ; x++ )
425    {
426        for ( y = 0 ; y < y_size ; y++ )
427        {
428            index = x * y_size + y;
429
430            if ( giet_pthread_join( trdid_demux[index] , NULL ) )
431            { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for demux[%d]\n", index ) }
432
433            if ( giet_pthread_join( trdid_vld[index] , NULL ) )
434            { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for vld[%d]\n", index ) }
435
436            if ( giet_pthread_join( trdid_iqzz[index] , NULL ) )
437            { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for iqzz[%d]\n", index ) }
438
439            if ( USE_DCT_COPROC == 0 )
440            {
441                if ( giet_pthread_join( trdid_idct[index] , NULL ) )
442                { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for idct[%d]\n", index ) }
443            }
444
445            if ( giet_pthread_join( trdid_libu[index] , NULL ) )
446            { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for libu[%d]\n", index ) }
447
448            if ( USE_DCT_COPROC )
449            {
450                uint32_t  cluster_xy  = (x<<4) + y;
451                uint32_t  coproc_type = 2;
452                giet_coproc_release( cluster_xy , coproc_type );
453            }
454        }
455    }
456
457    /////////////////////////////////////////////////////////////////////////////////////
458    // makes instrumentation
459    /////////////////////////////////////////////////////////////////////////////////////
460
461    PRINTF("\n[MJPEG] Instumentation Results\n" )
462    for ( image = 0 ; image < MAX_IMAGES ; image++ )
463    { PRINTF(" - Image %d : completed at cycle %d\n", image , date[image]) }
464
465    giet_pthread_exit( "main completed" );
466   
467} // end main()
468
Note: See TracBrowser for help on using the repository browser.