; generated by Component: ARM Compiler 5.05 update 2 (build 169) Tool: ArmCC [4d0f38]
; commandline ArmCC [--c99 --list --split_sections --debug -c --asm --interleave -o..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\camera_data_queue.o --asm_dir=..\..\..\..\Build\demo\MICO-Fire_F429\list_RVMDK\ --list_dir=..\..\..\..\Build\demo\MICO-Fire_F429\list_RVMDK\ --depend=..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\camera_data_queue.d --cpu=Cortex-M4.fp --apcs=interwork -O0 --diag_suppress=9931,1,1293 -I..\..\..\..\Board\fire_F429 -I..\..\..\..\Demos\fire\ov2640 -I..\..\..\..\include -I..\..\..\..\libraries\utilities -I..\..\..\..\libraries\utilities\json_c -I..\..\..\..\MICO\core -I..\..\..\..\MICO\security -I..\..\..\..\MICO\system -I..\..\..\..\MICO\system\command_console -I..\..\..\..\Platform\include -I..\..\..\..\Platform\Cortex-M4 -I..\..\..\..\Platform\Cortex-M4\CMSIS -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries\STM32F4xx_StdPeriph_Driver\inc -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries -I..\..\..\..\Platform\MCU\STM32F4xx\wlan_bus_driver -I..\..\..\..\Platform\Drivers\spi_flash -I..\..\..\..\Platform\Drivers -I..\..\..\..\libraries\daemons\homekit_server -I..\..\..\..\libraries\daemons\http_server -I..\..\..\..\Platform\Drivers\malloc -I..\..\..\..\Platform\Drivers\SDRAM -I..\..\..\..\Platform\Drivers\ov5640 -IG:\GIT_OSC\STM32_develop\F429-V2\develop\6-WIFI\STM32-WiFi\3.wifi_ov5640\Projects\STM32F429\demo\RVMDK\RTE -IC:\Keil_v5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0\Drivers\CMSIS\Device\ST\STM32F4xx\Include -IC:\Keil_v5\ARM\CMSIS\Include -IC:\Keil_v5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0 -D__UVISION_VERSION=515 -DSTM32F429xx -DUSE_STDPERIPH_DRIVER -DDEBUG -DHSE_VALUE=25000000 -DOV5640 --omf_browse=..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\camera_data_queue.crf ..\..\..\..\Demos\fire\ov2640\camera_data_queue.c]
                          THUMB

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

                  camera_queue_free PROC
;;;148    //ͷеָָĻȫ
;;;149    void camera_queue_free(void)
000000  b510              PUSH     {r4,lr}
;;;150    {
;;;151        uint32_t i = 0;
000002  2400              MOVS     r4,#0
;;;152    
;;;153        for(i = 0; i < CAMERA_QUEUE_NUM; i ++)
000004  bf00              NOP      
000006  e010              B        |L1.42|
                  |L1.8|
;;;154        {
;;;155            if(cam_data[i].head != NULL)
000008  4809              LDR      r0,|L1.48|
00000a  eb001004          ADD      r0,r0,r4,LSL #4
00000e  6800              LDR      r0,[r0,#0]
000010  b150              CBZ      r0,|L1.40|
;;;156            {
;;;157                free(cam_data[i].head);
000012  4907              LDR      r1,|L1.48|
000014  eb011104          ADD      r1,r1,r4,LSL #4
000018  6808              LDR      r0,[r1,#0]
00001a  f7fffffe          BL       free
;;;158                cam_data[i].head = NULL;
00001e  2000              MOVS     r0,#0
000020  4903              LDR      r1,|L1.48|
000022  eb011104          ADD      r1,r1,r4,LSL #4
000026  6008              STR      r0,[r1,#0]
                  |L1.40|
000028  1c64              ADDS     r4,r4,#1              ;153
                  |L1.42|
00002a  2c02              CMP      r4,#2                 ;153
00002c  d3ec              BCC      |L1.8|
;;;159            }
;;;160        }
;;;161    
;;;162        return;
;;;163    }
00002e  bd10              POP      {r4,pc}
;;;164    
                          ENDP

                  |L1.48|
                          DCD      cam_data

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

                  camera_queue_init PROC
;;;165    //гʼڴ
;;;166    OSStatus camera_queue_init(void)
000000  b510              PUSH     {r4,lr}
;;;167    {
;;;168      uint32_t i = 0;
000002  2400              MOVS     r4,#0
;;;169    
;;;170      memset(cam_data, 0, sizeof(cam_data));
000004  2120              MOVS     r1,#0x20
000006  4812              LDR      r0,|L2.80|
000008  f7fffffe          BL       __aeabi_memclr4
;;;171    		
;;;172    	/*ʼ*/
;;;173    	cbInit(&cam_circular_buff,CAMERA_QUEUE_NUM);
00000c  2102              MOVS     r1,#2
00000e  4811              LDR      r0,|L2.84|
000010  f7fffffe          BL       cbInit
;;;174    
;;;175        for(i = 0; i < CAMERA_QUEUE_NUM; i ++)
000014  bf00              NOP      
000016  e016              B        |L2.70|
                  |L2.24|
;;;176        {
;;;177            cam_data[i].head = queue_buff[i];//cam_global_buf+CAMERA_QUEUE_DATA_LEN*i;
000018  480f              LDR      r0,|L2.88|
00001a  eb005084          ADD      r0,r0,r4,LSL #22
00001e  490c              LDR      r1,|L2.80|
000020  eb011104          ADD      r1,r1,r4,LSL #4
000024  6008              STR      r0,[r1,#0]
;;;178            
;;;179            /*ʼлָ룬ָʵʵڴ*/
;;;180            cam_circular_buff.elems[i] = &cam_data[i];
000026  480a              LDR      r0,|L2.80|
000028  eb001104          ADD      r1,r0,r4,LSL #4
00002c  4809              LDR      r0,|L2.84|
00002e  3014              ADDS     r0,r0,#0x14
000030  f8401024          STR      r1,[r0,r4,LSL #2]
;;;181            
;;;182            camera_data_queue_log("cam_data[i].head=0x%x,cam_circular_buff.elems[i] =0x%x", (uint32_t)cam_data[i].head,(uint32_t)cam_circular_buff.elems[i]->head);
;;;183    
;;;184            memset(cam_data[i].head, 0, CAMERA_QUEUE_DATA_LEN);
000034  4906              LDR      r1,|L2.80|
000036  eb011104          ADD      r1,r1,r4,LSL #4
00003a  6808              LDR      r0,[r1,#0]
00003c  f44f0180          MOV      r1,#0x400000
000040  f7fffffe          BL       __aeabi_memclr
000044  1c64              ADDS     r4,r4,#1              ;175
                  |L2.70|
000046  2c02              CMP      r4,#2                 ;175
000048  d3e6              BCC      |L2.24|
;;;185        }
;;;186    
;;;187        return kNoErr;
00004a  2000              MOVS     r0,#0
;;;188    }
00004c  bd10              POP      {r4,pc}
;;;189    
                          ENDP

00004e  0000              DCW      0x0000
                  |L2.80|
                          DCD      cam_data
                  |L2.84|
                          DCD      cam_circular_buff
                  |L2.88|
                          DCD      queue_buff

                          AREA ||i.cbIncr||, CODE, READONLY, ALIGN=1

                  cbIncr PROC
;;;75       */	
;;;76     int cbIncr(CircularBuffer *cb, int p) 
000000  4602              MOV      r2,r0
;;;77     {
;;;78         return (p + 1)&(2*cb->size-1); /* start and end pointers incrementation is done modulo 2*size */
000002  6810              LDR      r0,[r2,#0]
000004  0040              LSLS     r0,r0,#1
000006  1e40              SUBS     r0,r0,#1
000008  1c4b              ADDS     r3,r1,#1
00000a  4018              ANDS     r0,r0,r3
;;;79     }
00000c  4770              BX       lr
;;;80      
                          ENDP


                          AREA ||i.cbInit||, CODE, READONLY, ALIGN=1

                  cbInit PROC
;;;33       */
;;;34     void cbInit(CircularBuffer *cb, int size) 
000000  6001              STR      r1,[r0,#0]
;;;35     {
;;;36         cb->size  = size;	/* maximum number of elements           */
;;;37         cb->start = 0; 		/* index of oldest element              */
000002  2200              MOVS     r2,#0
000004  6042              STR      r2,[r0,#4]
;;;38         cb->end   = 0; 	 	/* index at which to write new element  */
000006  6082              STR      r2,[r0,#8]
;;;39     //    cb->elems = (uint8_t *)calloc(cb->size, sizeof(uint8_t));  //elems Ҫʼ
;;;40     }
000008  4770              BX       lr
;;;41      
                          ENDP


                          AREA ||i.cbIsEmpty||, CODE, READONLY, ALIGN=1

                  cbIsEmpty PROC
;;;64       */		
;;;65     int cbIsEmpty(CircularBuffer *cb) 
000000  4601              MOV      r1,r0
;;;66     {
;;;67         return cb->end == cb->start; 
000002  e9d12001          LDRD     r2,r0,[r1,#4]
000006  4290              CMP      r0,r2
000008  d101              BNE      |L5.14|
00000a  2001              MOVS     r0,#1
                  |L5.12|
;;;68     }
00000c  4770              BX       lr
                  |L5.14|
00000e  2000              MOVS     r0,#0                 ;67
000010  e7fc              B        |L5.12|
;;;69     
                          ENDP


                          AREA ||i.cbIsFull||, CODE, READONLY, ALIGN=1

                  cbIsFull PROC
;;;55       */
;;;56     int cbIsFull(CircularBuffer *cb) 
000000  4601              MOV      r1,r0
;;;57     {
;;;58         return cb->end == (cb->start ^ cb->size); /* This inverts the most significant bit of start before comparison */ 
000002  e9d12000          LDRD     r2,r0,[r1,#0]
000006  4050              EORS     r0,r0,r2
000008  688a              LDR      r2,[r1,#8]
00000a  4290              CMP      r0,r2
00000c  d101              BNE      |L6.18|
00000e  2001              MOVS     r0,#1
                  |L6.16|
;;;59     }
000010  4770              BX       lr
                  |L6.18|
000012  2000              MOVS     r0,#0                 ;58
000014  e7fc              B        |L6.16|
;;;60      
                          ENDP


                          AREA ||i.cbPrint||, CODE, READONLY, ALIGN=1

                  cbPrint PROC
;;;45       */
;;;46     void cbPrint(CircularBuffer *cb) 
000000  4770              BX       lr
;;;47     {
;;;48         camera_data_queue_log("size=0x%x, start=%d, end=%d\n", cb->size, cb->start, cb->end);
;;;49     	  camera_data_queue_log("size=0x%x, start_using=%d, end_using=%d\n", cb->size, cb->start_using, cb->end_using);
;;;50     }
;;;51      
                          ENDP


                          AREA ||i.cbRead||, CODE, READONLY, ALIGN=1

                  cbRead PROC
;;;123      */
;;;124    camera_data* cbRead(CircularBuffer *cb) 
000000  b510              PUSH     {r4,lr}
;;;125    {
000002  4604              MOV      r4,r0
;;;126    		if(cbIsEmpty(cb))
000004  4620              MOV      r0,r4
000006  f7fffffe          BL       cbIsEmpty
00000a  b108              CBZ      r0,|L8.16|
;;;127    			return NULL;
00000c  2000              MOVS     r0,#0
                  |L8.14|
;;;128    		
;;;129    	cb->start_using = cbIncr(cb, cb->start);
;;;130    	return cb->elems[cb->start_using&(cb->size-1)];
;;;131    }
00000e  bd10              POP      {r4,pc}
                  |L8.16|
000010  4620              MOV      r0,r4                 ;129
000012  6861              LDR      r1,[r4,#4]            ;129
000014  f7fffffe          BL       cbIncr
000018  60e0              STR      r0,[r4,#0xc]          ;129
00001a  6821              LDR      r1,[r4,#0]            ;130
00001c  1e49              SUBS     r1,r1,#1              ;130
00001e  68e0              LDR      r0,[r4,#0xc]          ;130
000020  4008              ANDS     r0,r0,r1              ;130
000022  f1040114          ADD      r1,r4,#0x14           ;130
000026  f8510020          LDR      r0,[r1,r0,LSL #2]     ;130
00002a  e7f0              B        |L8.14|
;;;132    
                          ENDP


                          AREA ||i.cbReadFinish||, CODE, READONLY, ALIGN=1

                  cbReadFinish PROC
;;;137      */
;;;138    void cbReadFinish(CircularBuffer *cb) 
000000  68c1              LDR      r1,[r0,#0xc]
;;;139    {
;;;140        cb->start = cb->start_using;
000002  6041              STR      r1,[r0,#4]
;;;141    }
000004  4770              BX       lr
;;;142    
                          ENDP


                          AREA ||i.cbWrite||, CODE, READONLY, ALIGN=1

                  cbWrite PROC
;;;86       */
;;;87     camera_data* cbWrite(CircularBuffer *cb) 
000000  b510              PUSH     {r4,lr}
;;;88     {
000002  4604              MOV      r4,r0
;;;89         if (cbIsFull(cb)) /* full, overwrite moves start pointer */
000004  4620              MOV      r0,r4
000006  f7fffffe          BL       cbIsFull
00000a  b108              CBZ      r0,|L10.16|
;;;90         {
;;;91     			return NULL;
00000c  2000              MOVS     r0,#0
                  |L10.14|
;;;92     		}		
;;;93     		else
;;;94     			cb->end_using = cbIncr(cb, cb->end); //δ1
;;;95     		
;;;96     	return  cb->elems[cb->end_using&(cb->size-1)];
;;;97     }
00000e  bd10              POP      {r4,pc}
                  |L10.16|
000010  4620              MOV      r0,r4                 ;94
000012  68a1              LDR      r1,[r4,#8]            ;94
000014  f7fffffe          BL       cbIncr
000018  6120              STR      r0,[r4,#0x10]         ;94
00001a  6821              LDR      r1,[r4,#0]            ;96
00001c  1e49              SUBS     r1,r1,#1              ;96
00001e  6920              LDR      r0,[r4,#0x10]         ;96
000020  4008              ANDS     r0,r0,r1              ;96
000022  f1040114          ADD      r1,r4,#0x14           ;96
000026  f8510020          LDR      r0,[r1,r0,LSL #2]     ;96
00002a  e7f0              B        |L10.14|
;;;98     
                          ENDP


                          AREA ||i.cbWriteFinish||, CODE, READONLY, ALIGN=1

                  cbWriteFinish PROC
;;;112      */
;;;113    void cbWriteFinish(CircularBuffer *cb)
000000  6901              LDR      r1,[r0,#0x10]
;;;114    {
;;;115        cb->end = cb->end_using;
000002  6081              STR      r1,[r0,#8]
;;;116    }
000004  4770              BX       lr
;;;117     
                          ENDP


                          AREA ||i.cbWriteUsing||, CODE, READONLY, ALIGN=1

                  cbWriteUsing PROC
;;;103      */
;;;104    camera_data* cbWriteUsing(CircularBuffer *cb) 
000000  4601              MOV      r1,r0
;;;105    {
;;;106    	return  cb->elems[cb->end_using&(cb->size-1)];
000002  680a              LDR      r2,[r1,#0]
000004  1e52              SUBS     r2,r2,#1
000006  6908              LDR      r0,[r1,#0x10]
000008  4010              ANDS     r0,r0,r2
00000a  f1010214          ADD      r2,r1,#0x14
00000e  f8520020          LDR      r0,[r2,r0,LSL #2]
;;;107    }
000012  4770              BX       lr
;;;108    
                          ENDP


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

                  find_jpeg PROC
;;;400      */
;;;401    int32_t find_jpeg(camera_data *cambuf) 
000000  b570              PUSH     {r4-r6,lr}
;;;402    {
000002  4602              MOV      r2,r0
;;;403    	uint32_t i = 0,j=0;
000004  2300              MOVS     r3,#0
000006  bf00              NOP      
;;;404    	
;;;405    	uint8_t *p = cambuf->head;	
000008  6811              LDR      r1,[r2,#0]
;;;406    	
;;;407    	/*ļβ*/
;;;408    	uint32_t end_search_point = cambuf->img_dma_len*99/100;
00000a  6850              LDR      r0,[r2,#4]
00000c  eb001040          ADD      r0,r0,r0,LSL #5
000010  eb000040          ADD      r0,r0,r0,LSL #1
000014  2664              MOVS     r6,#0x64
000016  fb90f5f6          SDIV     r5,r0,r6
;;;409    	
;;;410    	/**/
;;;411    	cambuf->img_real_start = NULL;	
00001a  2000              MOVS     r0,#0
00001c  6090              STR      r0,[r2,#8]
;;;412    	cambuf->img_real_len = -1;
00001e  1e40              SUBS     r0,r0,#1
000020  60d0              STR      r0,[r2,#0xc]
;;;413    
;;;414    	for(j = 0;j<JPEG_HEAD_SEARCH_MAX;j++)
000022  2400              MOVS     r4,#0
000024  e031              B        |L13.138|
                  |L13.38|
;;;415    	{
;;;416    		if(! ((*p == 0xFF) && (*(p + 1) == 0xD8)) ) //֡ͷ
000026  7808              LDRB     r0,[r1,#0]
000028  28ff              CMP      r0,#0xff
00002a  d102              BNE      |L13.50|
00002c  7848              LDRB     r0,[r1,#1]
00002e  28d8              CMP      r0,#0xd8
000030  d001              BEQ      |L13.54|
                  |L13.50|
;;;417    		{
;;;418    			p++;
000032  1c49              ADDS     r1,r1,#1
000034  e028              B        |L13.136|
                  |L13.54|
;;;419    		}
;;;420        else if((*p == 0xFF) && (*(p + 1) == 0xD8)) //֡ͷж
000036  7808              LDRB     r0,[r1,#0]
000038  28ff              CMP      r0,#0xff
00003a  d125              BNE      |L13.136|
00003c  7848              LDRB     r0,[r1,#1]
00003e  28d8              CMP      r0,#0xd8
000040  d122              BNE      |L13.136|
;;;421        {
;;;422    			if(j!=0)			
;;;423    			{	
;;;424    				/*ļͷʵƫ*/
;;;425    				camera_data_queue_log("JPEG_HEAD_SEARCH *p=0x%x,j=%d", *p,j );
;;;426    			}
;;;427    			
;;;428    				/*ļͷʵָ*/
;;;429    				cambuf->img_real_start = p;
000042  6091              STR      r1,[r2,#8]
;;;430    
;;;431    				/*ļβ*/
;;;432    				p += end_search_point;
000044  4429              ADD      r1,r1,r5
;;;433    			
;;;434            for(i = end_search_point ; i < CAMERA_QUEUE_DATA_LEN - 2; i ++)
000046  462b              MOV      r3,r5
000048  e018              B        |L13.124|
                  |L13.74|
;;;435            {
;;;436                if((*p == 0xFF) && (*(p + 1) == 0xD8))
00004a  7808              LDRB     r0,[r1,#0]
00004c  28ff              CMP      r0,#0xff
00004e  d108              BNE      |L13.98|
000050  7848              LDRB     r0,[r1,#1]
000052  28d8              CMP      r0,#0xd8
000054  d105              BNE      |L13.98|
;;;437                {
;;;438                    if(i == 0)
000056  b90b              CBNZ     r3,|L13.92|
;;;439                    {
;;;440                        p++;
000058  1c49              ADDS     r1,r1,#1
;;;441                        continue;
00005a  e00e              B        |L13.122|
                  |L13.92|
;;;442                    }else
;;;443                    {
;;;444                        return kGeneralErr;
00005c  f04f30ff          MOV      r0,#0xffffffff
                  |L13.96|
;;;445                    }
;;;446                }else if((*p == 0xFF) && (*(p + 1) == 0xD9))
;;;447                {
;;;448    								camera_data_queue_log("pic len = %d", i+2 );
;;;449    
;;;450    								cambuf->img_real_len = i+2;
;;;451                    return  kNoErr;
;;;452                }
;;;453    
;;;454                p++;
;;;455            }  	
;;;456    				
;;;457    				camera_data_queue_log("picture tail error!");
;;;458    				return kGeneralErr;				
;;;459        }
;;;460    	}
;;;461    
;;;462    	
;;;463      camera_data_queue_log("picture head error!");	
;;;464    	
;;;465      return kGeneralErr;
;;;466    }
000060  bd70              POP      {r4-r6,pc}
                  |L13.98|
000062  7808              LDRB     r0,[r1,#0]            ;446
000064  28ff              CMP      r0,#0xff              ;446
000066  d106              BNE      |L13.118|
000068  7848              LDRB     r0,[r1,#1]            ;446
00006a  28d9              CMP      r0,#0xd9              ;446
00006c  d103              BNE      |L13.118|
00006e  1c98              ADDS     r0,r3,#2              ;450
000070  60d0              STR      r0,[r2,#0xc]          ;450
000072  2000              MOVS     r0,#0                 ;451
000074  e7f4              B        |L13.96|
                  |L13.118|
000076  1c49              ADDS     r1,r1,#1              ;454
000078  bf00              NOP                            ;441
                  |L13.122|
00007a  1c5b              ADDS     r3,r3,#1              ;434
                  |L13.124|
00007c  4805              LDR      r0,|L13.148|
00007e  4283              CMP      r3,r0                 ;434
000080  d3e3              BCC      |L13.74|
000082  f04f30ff          MOV      r0,#0xffffffff        ;458
000086  e7eb              B        |L13.96|
                  |L13.136|
000088  1c64              ADDS     r4,r4,#1              ;414
                  |L13.138|
00008a  2c28              CMP      r4,#0x28              ;414
00008c  d3cb              BCC      |L13.38|
00008e  f04f30ff          MOV      r0,#0xffffffff        ;465
000092  e7e5              B        |L13.96|
;;;467    
                          ENDP

                  |L13.148|
                          DCD      0x003ffffe

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

                  find_jpeg_tail PROC
;;;300    
;;;301    int32_t find_jpeg_tail(uint8_t *data,uint8_t *jpeg_start,int32_t search_point) 
000000  b5f0              PUSH     {r4-r7,lr}
;;;302    {
000002  4606              MOV      r6,r0
000004  460c              MOV      r4,r1
000006  4615              MOV      r5,r2
;;;303        uint32_t i = 0,j=0,z=0;
000008  2200              MOVS     r2,#0
00000a  2300              MOVS     r3,#0
00000c  2700              MOVS     r7,#0
;;;304        uint8_t *p = data;
00000e  4631              MOV      r1,r6
;;;305    	
;;;306    	/*Ĭļͷλ*/
;;;307    	*jpeg_start = 0;
000010  2000              MOVS     r0,#0
000012  7020              STRB     r0,[r4,#0]
;;;308    
;;;309    	for(j = 0;j<JPEG_HEAD_SEARCH_MAX;j++)
000014  bf00              NOP      
000016  e030              B        |L14.122|
                  |L14.24|
;;;310    	{
;;;311    		if(! ((*p == 0xFF) && (*(p + 1) == 0xD8)) ) //֡ͷ
000018  7808              LDRB     r0,[r1,#0]
00001a  28ff              CMP      r0,#0xff
00001c  d102              BNE      |L14.36|
00001e  7848              LDRB     r0,[r1,#1]
000020  28d8              CMP      r0,#0xd8
000022  d001              BEQ      |L14.40|
                  |L14.36|
;;;312    		{
;;;313    			p++;
000024  1c49              ADDS     r1,r1,#1
000026  e027              B        |L14.120|
                  |L14.40|
;;;314    		}
;;;315        else if((*p == 0xFF) && (*(p + 1) == 0xD8)) //֡ͷж
000028  7808              LDRB     r0,[r1,#0]
00002a  28ff              CMP      r0,#0xff
00002c  d124              BNE      |L14.120|
00002e  7848              LDRB     r0,[r1,#1]
000030  28d8              CMP      r0,#0xd8
000032  d121              BNE      |L14.120|
;;;316        {
;;;317    			if(j!=0)			
000034  b103              CBZ      r3,|L14.56|
;;;318    			{
;;;319    				camera_data_queue_log("JPEG_HEAD_SEARCH_MAX *p=0x%x,j=%d", *p,j );
;;;320    				/*ļͷʵƫ*/
;;;321    				*jpeg_start=j;
000036  7023              STRB     r3,[r4,#0]
                  |L14.56|
;;;322    			}
;;;323    
;;;324    				/**/
;;;325    				p += search_point;
000038  4429              ADD      r1,r1,r5
;;;326    			
;;;327            for(i = search_point ; i < CAMERA_QUEUE_DATA_LEN - 2; i ++)
00003a  462a              MOV      r2,r5
00003c  e016              B        |L14.108|
                  |L14.62|
;;;328            {
;;;329                if((*p == 0xFF) && (*(p + 1) == 0xD8))
00003e  7808              LDRB     r0,[r1,#0]
000040  28ff              CMP      r0,#0xff
000042  d108              BNE      |L14.86|
000044  7848              LDRB     r0,[r1,#1]
000046  28d8              CMP      r0,#0xd8
000048  d105              BNE      |L14.86|
;;;330                {
;;;331                    if(i == 0)
00004a  b90a              CBNZ     r2,|L14.80|
;;;332                    {
;;;333                        p++;
00004c  1c49              ADDS     r1,r1,#1
;;;334                        continue;
00004e  e00c              B        |L14.106|
                  |L14.80|
;;;335                    }else
;;;336                    {
;;;337                        return -1;
000050  f04f30ff          MOV      r0,#0xffffffff
                  |L14.84|
;;;338                    }
;;;339                }else if((*p == 0xFF) && (*(p + 1) == 0xD9))
;;;340                {
;;;341    								camera_data_queue_log("pic len = %d", i+2 );
;;;342    
;;;343                    return  i + 2;
;;;344                }
;;;345    
;;;346                p++;
;;;347            }  	
;;;348    				
;;;349    				camera_data_queue_log("picture tail error!");
;;;350    				return -1;				
;;;351        }
;;;352    	}
;;;353    #if 0 	//ڵԣ鿴ļͷ᲻ַ
;;;354    	{
;;;355    		extern uint32_t  XferTransferNumber;
;;;356    		extern uint32_t 	XferSize ;
;;;357    
;;;358    		for(j = 0;j<CAMERA_QUEUE_DATA_LEN;j++)
;;;359    		{
;;;360    			if(! ((*p == 0xFF) && (*(p + 1) == 0xD8)) ) //֡ͷ
;;;361    			{
;;;362    				p++;
;;;363    
;;;364    			}
;;;365    		else if((*p == 0xFF) && (*(p + 1) == 0xD8)) //֡ͷж
;;;366    		{
;;;367    			camera_data_queue_log("555555555555555555555555555555555555555");
;;;368    			camera_data_queue_log("found head at xfer z= %d ,p =0x%x",z,(int32_t)p);
;;;369    			break;
;;;370    
;;;371    		}
;;;372    	 }
;;;373    			
;;;374    	}
;;;375    #endif		
;;;376    	
;;;377      camera_data_queue_log("picture head error!");	
;;;378    	
;;;379      return -1;
;;;380    }
000054  bdf0              POP      {r4-r7,pc}
                  |L14.86|
000056  7808              LDRB     r0,[r1,#0]            ;339
000058  28ff              CMP      r0,#0xff              ;339
00005a  d104              BNE      |L14.102|
00005c  7848              LDRB     r0,[r1,#1]            ;339
00005e  28d9              CMP      r0,#0xd9              ;339
000060  d101              BNE      |L14.102|
000062  1c90              ADDS     r0,r2,#2              ;343
000064  e7f6              B        |L14.84|
                  |L14.102|
000066  1c49              ADDS     r1,r1,#1              ;346
000068  bf00              NOP                            ;334
                  |L14.106|
00006a  1c52              ADDS     r2,r2,#1              ;327
                  |L14.108|
00006c  4805              LDR      r0,|L14.132|
00006e  4282              CMP      r2,r0                 ;327
000070  d3e5              BCC      |L14.62|
000072  f04f30ff          MOV      r0,#0xffffffff        ;350
000076  e7ed              B        |L14.84|
                  |L14.120|
000078  1c5b              ADDS     r3,r3,#1              ;309
                  |L14.122|
00007a  2b28              CMP      r3,#0x28              ;309
00007c  d3cc              BCC      |L14.24|
00007e  f04f30ff          MOV      r0,#0xffffffff        ;379
000082  e7e7              B        |L14.84|
;;;381    
                          ENDP

                  |L14.132|
                          DCD      0x003ffffe

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

                  pull_data_from_queue PROC
;;;194    //Ӷȡ, data_p:ʼַ, len_p:, array_index:±
;;;195    OSStatus pull_data_from_queue(uint8_t **data_p, int32_t *len_p)
000000  e92d41f8          PUSH     {r3-r8,lr}
;;;196    {
000004  4606              MOV      r6,r0
000006  460d              MOV      r5,r1
;;;197    		int32_t len_p_get = 0 ;		
000008  f04f0800          MOV      r8,#0
;;;198    		uint8_t jpeg_start_offset = 0;	
00000c  2000              MOVS     r0,#0
00000e  9000              STR      r0,[sp,#0]
;;;199    		camera_data *cam_data_pull;	
;;;200    		uint32_t time_old,time_new;
;;;201    		
;;;202    		if(!cbIsEmpty(&cam_circular_buff))//зǿ
000010  4812              LDR      r0,|L15.92|
000012  f7fffffe          BL       cbIsEmpty
000016  b9e8              CBNZ     r0,|L15.84|
;;;203    		{
;;;204    				/*ӻȡݣд*/
;;;205    				cam_data_pull = cbRead(&cam_circular_buff);
000018  4810              LDR      r0,|L15.92|
00001a  f7fffffe          BL       cbRead
00001e  4604              MOV      r4,r0
;;;206    			
;;;207    				if (cam_data_pull == NULL)
000020  b91c              CBNZ     r4,|L15.42|
;;;208    						return kGeneralErr;
000022  f04f30ff          MOV      r0,#0xffffffff
                  |L15.38|
;;;209    #if 1				
;;;210    			/*ļ*/	
;;;211    				
;;;212    			*len_p = find_jpeg_tail(cam_data_pull->head,&jpeg_start_offset,cam_data_pull->img_dma_len*2/3);
;;;213    
;;;214    //			*len_p = find_jpeg_tail(cam_data_pull->head,&jpeg_start_offset,0);
;;;215    
;;;216    #elif 0		//ڵԣԱȿļٵ	
;;;217    				camera_data_queue_log("-------------------------------------");
;;;218    				
;;;219    				time_old = mico_get_time();			
;;;220    				*len_p = find_jpeg_tail(cam_data_pull->head,&jpeg_start_offset,cam_data_pull->img_dma_len*99/100);
;;;221    				time_new = mico_get_time();			
;;;222    				len_p_get =  cam_data_pull->img_real_len;
;;;223    			
;;;224    				camera_data_queue_log("find len = %d,get_len=%d",*len_p,len_p_get);
;;;225    				camera_data_queue_log("find time = %d ",time_new-time_old);
;;;226    			
;;;227    				camera_data_queue_log("---****************-------------");
;;;228    				time_old = mico_get_time();
;;;229    				*len_p = find_jpeg_tail(cam_data_pull->head,&jpeg_start_offset,0);
;;;230    
;;;231    				time_new = mico_get_time();
;;;232    			
;;;233    				camera_data_queue_log("find len = %d,get_len=%d",*len_p,len_p_get);
;;;234    				camera_data_queue_log("find time = %d ",time_new-time_old);
;;;235    				
;;;236    #else	//ڵԣԱȿļٵ	
;;;237    			
;;;238    				{
;;;239    							//ĸ
;;;240    					static uint8_t numerator = 99 ,denominator=100 ;
;;;241    
;;;242    					
;;;243    						time_old = mico_get_time();			
;;;244    						len_p_get = find_jpeg_tail(cam_data_pull->head,&jpeg_start_offset,cam_data_pull->img_dma_len*numerator/denominator);
;;;245    						time_new = mico_get_time();						
;;;246    
;;;247    
;;;248    			
;;;249    						time_old = mico_get_time();
;;;250    						*len_p = find_jpeg_tail(cam_data_pull->head,&jpeg_start_offset,0);
;;;251    						time_new = mico_get_time();
;;;252    						
;;;253    						if(len_p_get != *len_p )
;;;254    						{						
;;;255    
;;;256    							camera_data_queue_log("--------------different-------------");
;;;257    							camera_data_queue_log("fast find len = %d,find=%d",len_p_get,*len_p);
;;;258    							camera_data_queue_log("img_real_len = %d",cam_data_pull->img_dma_len);
;;;259    							
;;;260    							//ĸٳ
;;;261    							if(numerator != 1)
;;;262    							{
;;;263    								numerator--;
;;;264    								denominator--;					
;;;265    							}
;;;266    							camera_data_queue_log("newly search point =  %d/%d",numerator,denominator);
;;;267    
;;;268    
;;;269    						}
;;;270    						
;;;271    //						*len_p = len_p_get;
;;;272    				}
;;;273    			
;;;274    
;;;275    #endif			
;;;276    				
;;;277    				if(*len_p != -1)
;;;278    				{
;;;279    						*data_p = cam_data_pull->head + jpeg_start_offset;
;;;280    						return kNoErr;
;;;281    				}else
;;;282    				{
;;;283    				}		
;;;284    		}
;;;285    
;;;286        return kGeneralErr;
;;;287    }
000026  e8bd81f8          POP      {r3-r8,pc}
                  |L15.42|
00002a  6860              LDR      r0,[r4,#4]            ;212
00002c  0040              LSLS     r0,r0,#1              ;212
00002e  2103              MOVS     r1,#3                 ;212
000030  fb90f7f1          SDIV     r7,r0,r1              ;212
000034  463a              MOV      r2,r7                 ;212
000036  4669              MOV      r1,sp                 ;212
000038  6820              LDR      r0,[r4,#0]            ;212
00003a  f7fffffe          BL       find_jpeg_tail
00003e  6028              STR      r0,[r5,#0]            ;212
000040  6828              LDR      r0,[r5,#0]            ;277
000042  1c40              ADDS     r0,r0,#1              ;277
000044  b130              CBZ      r0,|L15.84|
000046  f89d1000          LDRB     r1,[sp,#0]            ;279
00004a  6820              LDR      r0,[r4,#0]            ;279
00004c  4408              ADD      r0,r0,r1              ;279
00004e  6030              STR      r0,[r6,#0]            ;279
000050  2000              MOVS     r0,#0                 ;280
000052  e7e8              B        |L15.38|
                  |L15.84|
000054  f04f30ff          MOV      r0,#0xffffffff        ;286
000058  e7e5              B        |L15.38|
;;;288    
                          ENDP

00005a  0000              DCW      0x0000
                  |L15.92|
                          DCD      cam_circular_buff

                          AREA ||.bss||, DATA, NOINIT, ALIGN=2

                  cam_data
                          %        32
                  cam_circular_buff
                          %        28

                          AREA EXRAM, DATA, ALIGN=2

                  queue_buff
                          %        8388608

;*** Start embedded assembler ***

#line 1 "..\\..\\..\\..\\Demos\\fire\\ov2640\\camera_data_queue.c"
	AREA ||.rev16_text||, CODE
	THUMB
	EXPORT |__asm___19_camera_data_queue_c_cbInit____REV16|
#line 114 "..\\..\\..\\..\\Platform\\Cortex-M4\\CMSIS\\core_cmInstr.h"
|__asm___19_camera_data_queue_c_cbInit____REV16| PROC
#line 115

 rev16 r0, r0
 bx lr
	ENDP
	AREA ||.revsh_text||, CODE
	THUMB
	EXPORT |__asm___19_camera_data_queue_c_cbInit____REVSH|
#line 128
|__asm___19_camera_data_queue_c_cbInit____REVSH| PROC
#line 129

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
