jdinput.txt

STM32F103ZET6+UCOSII+UCGUI源码

;;;68     				   compptr->h_samp_factor);
;;;69         cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
0000a4  f8c40134          STR      r0,[r4,#0x134]
0000a8  f8d40138          LDR      r0,[r4,#0x138]
0000ac  68e9              LDR      r1,[r5,#0xc]
0000ae  4288              CMP      r0,r1
0000b0  dc00              BGT      |L3.180|
0000b2  4608              MOV      r0,r1
                  |L3.180|
0000b4  1c7f              ADDS     r7,r7,#1              ;63
0000b6  3554              ADDS     r5,r5,#0x54           ;63
0000b8  f8c40138          STR      r0,[r4,#0x138]        ;63
                  |L3.188|
0000bc  6a60              LDR      r0,[r4,#0x24]         ;62
0000be  42b8              CMP      r0,r7                 ;62
0000c0  dcd9              BGT      |L3.118|
;;;70     				   compptr->v_samp_factor);
;;;71       }
;;;72     
;;;73       /* We initialize DCT_scaled_size and min_DCT_scaled_size to DCTSIZE.
;;;74        * In the full decompressor, this will be overridden by jdmaster.c;
;;;75        * but in the transcoder, jdmaster.c is not used, so we must do it here.
;;;76        */
;;;77       cinfo->min_DCT_scaled_size = DCTSIZE;
0000c2  f04f0808          MOV      r8,#8
;;;78     
;;;79       /* Compute dimensions of components */
;;;80       for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
0000c6  2700              MOVS     r7,#0
0000c8  f8c4813c          STR      r8,[r4,#0x13c]
0000cc  46b9              MOV      r9,r7                 ;62
0000ce  f8d450d8          LDR      r5,[r4,#0xd8]
0000d2  e028              B        |L3.294|
                  |L3.212|
;;;81            ci++, compptr++) {
;;;82         compptr->DCT_scaled_size = DCTSIZE;
;;;83         /* Size in DCT blocks */
;;;84         compptr->width_in_blocks = (JDIMENSION)
0000d4  f8c58024          STR      r8,[r5,#0x24]
0000d8  69e0              LDR      r0,[r4,#0x1c]
0000da  68a9              LDR      r1,[r5,#8]
0000dc  4348              MULS     r0,r1,r0
0000de  f8d41134          LDR      r1,[r4,#0x134]
0000e2  00c9              LSLS     r1,r1,#3
0000e4  f7fffffe          BL       jdiv_round_up
;;;85           jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
;;;86     		    (long) (cinfo->max_h_samp_factor * DCTSIZE));
;;;87         compptr->height_in_blocks = (JDIMENSION)
0000e8  61e8              STR      r0,[r5,#0x1c]
0000ea  6a20              LDR      r0,[r4,#0x20]
0000ec  68e9              LDR      r1,[r5,#0xc]
0000ee  4348              MULS     r0,r1,r0
0000f0  f8d41138          LDR      r1,[r4,#0x138]
0000f4  00c9              LSLS     r1,r1,#3
0000f6  f7fffffe          BL       jdiv_round_up
;;;88           jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
;;;89     		    (long) (cinfo->max_v_samp_factor * DCTSIZE));
;;;90         /* downsampled_width and downsampled_height will also be overridden by
;;;91          * jdmaster.c if we are doing full decompression.  The transcoder library
;;;92          * doesn't use these values, but the calling application might.
;;;93          */
;;;94         /* Size in samples */
;;;95         compptr->downsampled_width = (JDIMENSION)
0000fa  6228              STR      r0,[r5,#0x20]
0000fc  69e0              LDR      r0,[r4,#0x1c]
0000fe  68a9              LDR      r1,[r5,#8]
000100  4348              MULS     r0,r1,r0
000102  f8d41134          LDR      r1,[r4,#0x134]
000106  f7fffffe          BL       jdiv_round_up
;;;96           jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
;;;97     		    (long) cinfo->max_h_samp_factor);
;;;98         compptr->downsampled_height = (JDIMENSION)
00010a  62a8              STR      r0,[r5,#0x28]
00010c  6a20              LDR      r0,[r4,#0x20]
00010e  68e9              LDR      r1,[r5,#0xc]
000110  4348              MULS     r0,r1,r0
000112  f8d41138          LDR      r1,[r4,#0x138]
000116  f7fffffe          BL       jdiv_round_up
00011a  f8c5904c          STR      r9,[r5,#0x4c]         ;81
00011e  e9c5060b          STRD     r0,r6,[r5,#0x2c]      ;81
000122  1c7f              ADDS     r7,r7,#1              ;81
000124  3554              ADDS     r5,r5,#0x54           ;81
                  |L3.294|
000126  6a60              LDR      r0,[r4,#0x24]         ;80
000128  42b8              CMP      r0,r7                 ;80
00012a  dcd3              BGT      |L3.212|
;;;99           jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
;;;100    		    (long) cinfo->max_v_samp_factor);
;;;101        /* Mark component needed, until color conversion says otherwise */
;;;102        compptr->component_needed = TRUE;
;;;103        /* Mark no quantization table yet saved for component */
;;;104        compptr->quant_table = NULL;
;;;105      }
;;;106    
;;;107      /* Compute number of fully interleaved MCU rows. */
;;;108      cinfo->total_iMCU_rows = (JDIMENSION)
00012c  f8d40138          LDR      r0,[r4,#0x138]
000130  00c1              LSLS     r1,r0,#3
000132  6a20              LDR      r0,[r4,#0x20]
000134  f7fffffe          BL       jdiv_round_up
;;;109        jdiv_round_up((long) cinfo->image_height,
;;;110    		  (long) (cinfo->max_v_samp_factor*DCTSIZE));
;;;111    
;;;112      /* Decide whether file contains multiple scans */
;;;113      if (cinfo->comps_in_scan < cinfo->num_components || cinfo->progressive_mode)
000138  f8c40140          STR      r0,[r4,#0x140]
00013c  6a61              LDR      r1,[r4,#0x24]
00013e  f8d40148          LDR      r0,[r4,#0x148]
000142  4288              CMP      r0,r1
000144  db02              BLT      |L3.332|
000146  f8d400dc          LDR      r0,[r4,#0xdc]
00014a  b120              CBZ      r0,|L3.342|
                  |L3.332|
;;;114        cinfo->inputctl->has_multiple_scans = TRUE;
00014c  f8d401b4          LDR      r0,[r4,#0x1b4]
000150  6106              STR      r6,[r0,#0x10]
                  |L3.338|
;;;115      else
;;;116        cinfo->inputctl->has_multiple_scans = FALSE;
;;;117    }
000152  e8bd87f0          POP      {r4-r10,pc}
                  |L3.342|
000156  f8d411b4          LDR      r1,[r4,#0x1b4]        ;116
00015a  f8c19010          STR      r9,[r1,#0x10]         ;116
00015e  e7f8              B        |L3.338|
;;;118    
                          ENDP


                          AREA ||i.jinit_input_controller||, CODE, READONLY, ALIGN=2

                  jinit_input_controller PROC
;;;360    GLOBAL(void)
;;;361    jinit_input_controller (j_decompress_ptr cinfo)
000000  b510              PUSH     {r4,lr}
;;;362    {
000002  4604              MOV      r4,r0
;;;363      my_inputctl_ptr inputctl;
;;;364    
;;;365      /* Create subobject in permanent pool */
;;;366      inputctl = (my_inputctl_ptr)
000004  6840              LDR      r0,[r0,#4]
000006  221c              MOVS     r2,#0x1c
000008  6803              LDR      r3,[r0,#0]
00000a  2100              MOVS     r1,#0
00000c  4620              MOV      r0,r4
00000e  4798              BLX      r3
;;;367        (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
;;;368    				SIZEOF(my_input_controller));
;;;369      cinfo->inputctl = (struct jpeg_input_controller *) inputctl;
;;;370      /* Initialize method pointers */
;;;371      inputctl->pub.consume_input = consume_markers;
000010  4907              LDR      r1,|L4.48|
000012  f8c401b4          STR      r0,[r4,#0x1b4]
;;;372      inputctl->pub.reset_input_controller = reset_input_controller;
000016  6001              STR      r1,[r0,#0]
000018  4906              LDR      r1,|L4.52|
;;;373      inputctl->pub.start_input_pass = start_input_pass;
00001a  6041              STR      r1,[r0,#4]
00001c  4906              LDR      r1,|L4.56|
;;;374      inputctl->pub.finish_input_pass = finish_input_pass;
00001e  6081              STR      r1,[r0,#8]
000020  4906              LDR      r1,|L4.60|
;;;375      /* Initialize state: can't use reset_input_controller since we don't
;;;376       * want to try to reset other modules yet.
;;;377       */
;;;378      inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
000022  60c1              STR      r1,[r0,#0xc]
000024  2100              MOVS     r1,#0
;;;379      inputctl->pub.eoi_reached = FALSE;
000026  6101              STR      r1,[r0,#0x10]
;;;380      inputctl->inheaders = TRUE;
000028  6141              STR      r1,[r0,#0x14]
00002a  2101              MOVS     r1,#1
;;;381    }
00002c  6181              STR      r1,[r0,#0x18]
00002e  bd10              POP      {r4,pc}
                          ENDP

                  |L4.48|
                          DCD      consume_markers
                  |L4.52|
                          DCD      reset_input_controller
                  |L4.56|
                          DCD      start_input_pass
                  |L4.60|
                          DCD      finish_input_pass

                          AREA ||i.per_scan_setup||, CODE, READONLY, ALIGN=2

                  per_scan_setup PROC
;;;120    LOCAL(void)
;;;121    per_scan_setup (j_decompress_ptr cinfo)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;122    /* Do computations that are needed before processing a JPEG scan */
;;;123    /* cinfo->comps_in_scan and cinfo->cur_comp_info[] were set from SOS marker */
;;;124    {
000004  4604              MOV      r4,r0
;;;125      int ci, mcublks, tmp;
;;;126      jpeg_component_info *compptr;
;;;127      
;;;128      if (cinfo->comps_in_scan == 1) {
000006  f8d00148          LDR      r0,[r0,#0x148]
00000a  2500              MOVS     r5,#0                 ;125
00000c  2801              CMP      r0,#1
00000e  d11d              BNE      |L5.76|
;;;129        
;;;130        /* Noninterleaved (single-component) scan */
;;;131        compptr = cinfo->cur_comp_info[0];
;;;132        
;;;133        /* Overall image size in MCUs */
;;;134        cinfo->MCUs_per_row = compptr->width_in_blocks;
000010  f8d4014c          LDR      r0,[r4,#0x14c]
;;;135        cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
;;;136        
;;;137        /* For noninterleaved scan, always one block per MCU */
;;;138        compptr->MCU_width = 1;
000014  2601              MOVS     r6,#1
000016  69c1              LDR      r1,[r0,#0x1c]         ;134
000018  f8c4115c          STR      r1,[r4,#0x15c]        ;135
00001c  6a01              LDR      r1,[r0,#0x20]         ;135
00001e  f8c41160          STR      r1,[r4,#0x160]
;;;139        compptr->MCU_height = 1;
000022  6346              STR      r6,[r0,#0x34]
;;;140        compptr->MCU_blocks = 1;
000024  6386              STR      r6,[r0,#0x38]
;;;141        compptr->MCU_sample_width = compptr->DCT_scaled_size;
000026  63c6              STR      r6,[r0,#0x3c]
000028  6a41              LDR      r1,[r0,#0x24]
;;;142        compptr->last_col_width = 1;
;;;143        /* For noninterleaved scans, it is convenient to define last_row_height
;;;144         * as the number of block rows present in the last iMCU row.
;;;145         */
;;;146        tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
00002a  e9c01610          STRD     r1,r6,[r0,#0x40]
00002e  6a03              LDR      r3,[r0,#0x20]
000030  68c2              LDR      r2,[r0,#0xc]
000032  fbb3f1f2          UDIV     r1,r3,r2
000036  fb023111          MLS      r1,r2,r1,r3
;;;147        if (tmp == 0) tmp = compptr->v_samp_factor;
00003a  b901              CBNZ     r1,|L5.62|
00003c  4611              MOV      r1,r2
                  |L5.62|
;;;148        compptr->last_row_height = tmp;
;;;149        
;;;150        /* Prepare array describing MCU composition */
;;;151        cinfo->blocks_in_MCU = 1;
00003e  6481              STR      r1,[r0,#0x48]
;;;152        cinfo->MCU_membership[0] = 0;
000040  f8c46164          STR      r6,[r4,#0x164]
000044  f8c45168          STR      r5,[r4,#0x168]
                  |L5.72|
;;;153        
;;;154      } else {
;;;155        
;;;156        /* Interleaved (multi-component) scan */