// channel if from 0 static void menu_set_adc_direction(u8 channel) { u16 adc, calm; // for channel 2 use throttle, for others steering if (channel == 1) { adc = adc_throttle_ovs; calm = cg.calib_throttle_mid; } else { adc = adc_steering_ovs; calm = cg.calib_steering_mid; } // check steering firstly if (adc_steering_ovs < ((cg.calib_steering_mid - 40) << ADC_OVS_SHIFT)) menu_adc_direction = 0; else if (adc_steering_ovs > ((cg.calib_steering_mid + 40) << ADC_OVS_SHIFT)) menu_adc_direction = 1; // then check throttle if (adc_throttle_ovs < ((cg.calib_throttle_mid - 40) << ADC_OVS_SHIFT)) menu_adc_direction = 0; else if (adc_throttle_ovs > ((cg.calib_throttle_mid + 40) << ADC_OVS_SHIFT)) menu_adc_direction = 1; // and then CH3 button else if (btn(BTN_CH3)) menu_adc_direction ^= 1; // if this channel is using forced values, set it to left/right if (menu_force_value_channel) menu_force_value = menu_adc_direction ? PPM(500) : PPM(-500); }
void menu_et_function_set_from_linear(u8 n, s16 lin_val) { et_functions_s *etf = &et_functions[n]; s16 val; if (n == 0 || n >= ET_FUNCTIONS_SIZE) return; // OFF or bad // map lin_val between min and max val = (s16)((s32)(lin_val + PPM(500)) * (etf->max - etf->min + 1) / PPM(1000)) + etf->min; if (val > etf->max) val = etf->max; // lin_val was full right AVAL(val); }
// calculate length of SYNC signal (substract previous channel values) // also sets flag for ppm_interrupt to use new values // also starts TIM3 at first call void ppm_calc_sync(void) { // ARR must be set to computed value - 1, that is why we are substracting // 5000, it is quicker way to "add 5000" and then substract 1 from result *(u16 *)(&ppm_values[0]) = (u16)(((10 * (u32)PPM_FRAME_LENGTH - ppm_microsecs01) * PPM_MUL_SYNC - PPM(500)) / PPM(1000)); ppm_microsecs01 = 0; // for first ppm values, enable timer if (ppm_enabled) return; ppm_enabled = 1; BSET(TIM3_EGR, 0); // generate update event BSET(TIM3_CR1, 0); // enable timer }
ideal FrbAlexanderDual(const ideal& I, ConstRefPPMonoidElem pp) { MustHaveMonomialGens(I, "FrbAlexanderDual"); const SparsePolyRing polyRing = RingOf(I); if (PPM(polyRing) != owner(pp)) CoCoA_ERROR(ERR::MixedPPMs, "FrbAlexanderDual"); const std::size_t count = NumIndets(polyRing); Frobby::Ideal frobbyIdeal(count); ToFrobbyIdeal(frobbyIdeal, I); FrobbyMonomialIdealConsumer consumer(polyRing); // Set up the point to dualize on. WrappedMpzT* exponentVector = new WrappedMpzT[count]; try { for (size_t indep = 0; indep < count; ++indep) mpz_set(exponentVector[indep].getMpzT(), mpzref(BigExponent(pp, indep))); // Compute Alexander dual using Frobby. Frobby::alexanderDual(frobbyIdeal, (mpz_t*)exponentVector, consumer); } catch (...) { delete[] exponentVector; throw; } delete[] exponentVector; return consumer.getIdealsRef().back(); }
void ppm_set_value(u8 channel, u16 microsec01) { ppm_microsecs01 += microsec01; // ARR must be set to computed value - 1, that is why we are substracting // 5000, it is quicker way to "add 5000" and then substract 1 from result *(u16 *)(&ppm_values[(u8)(channel << 1)]) = (u16)(((u32)microsec01 * PPM_MUL_SERVO - PPM(500)) / PPM(1000)); // for first channel, when we are still in HW SYNC generate, update // new ARR values to get it applied now if (channel == 1) { sim(); if (ppm_channel2 == 4) { // next will be channel2, so we have channel1 in ARR now TIM3_ARRH = ppm_values[2]; TIM3_ARRL = ppm_values[3]; } rim(); } }
glm::mat4 Camera::PerspectiveProjectionMatrix() { //Get the dimension of the image plane first const float TOP = near_clip * tan(fovy*DEG2RAD/2); const float BOTTOM = - TOP; const float RIGHT = TOP*aspect; const float LEFT = -RIGHT; //constrcut the matrix by contructing the 4 column vectors glm::vec4 VM_1(2*near_clip /(RIGHT - LEFT), 0, 0, 0); glm::vec4 VM_2(0, 2*near_clip /(TOP - BOTTOM), 0, 0); glm::vec4 VM_3(-(RIGHT + LEFT)/(RIGHT - LEFT), -(TOP + BOTTOM)/(TOP - BOTTOM), far_clip/(far_clip - near_clip), 1); glm::vec4 VM_4(0, 0, -(far_clip * near_clip)/(far_clip - near_clip), 0); glm::mat4 PPM (VM_1, VM_2, VM_3, VM_4); return PPM; }
// Simple rather than efficient (esp. the call to eval) std::vector<RingElem> BM_generic(const SparsePolyRing& P, const ConstMatrixView& pts) { if (CoeffRing(P) != RingOf(pts)) CoCoA_ERROR(ERR::MixedRings, "Buchberger-Moeller"); if (NumIndets(P) < NumCols(pts)) CoCoA_ERROR(ERR::IncompatDims, "Buchberger-Moeller"); const long NumPts = NumRows(pts); const long dim = NumCols(pts); const ring k = CoeffRing(P); vector<RingElem> GB; const PPMonoid TT = PPM(P); QBGenerator QBG(TT); QBG.myCornerPPIntoQB(one(TT)); matrix M = NewDenseMat(k, 1, NumPts); // Fill first row with 1: for (int i=0; i<NumPts; ++i) SetEntry(M,0,i, 1); // The next loop removes the last indets from consideration. for (int i=dim; i < NumIndets(TT); ++i) QBG.myCornerPPIntoAvoidSet(indet(TT,i)); while (!QBG.myCorners().empty()) { const PPMonoidElem t = QBG.myCorners().front(); const vector<RingElem> v = eval(t, pts); ConstMatrixView NewRow = RowMat(v); const matrix a = LinSolve(transpose(M), transpose(NewRow)); if (IsValidSolution(a)) { QBG.myCornerPPIntoAvoidSet(t); RingElem NewGBElem = monomial(P, one(k), t); const vector<PPMonoidElem>& QB = QBG.myQB(); for (int i=0; i < NumRows(M); ++i) NewGBElem -= monomial(P, a(i,0), QB[i]); GB.push_back(NewGBElem); } else { QBG.myCornerPPIntoQB(t); M = NewDenseMat(ConcatVer(M, NewRow)); } } return GB; }
std::vector<RingElem> BM_modp(const SparsePolyRing& P, const ConstMatrixView& pts) { ring Fp = CoeffRing(P); const int NumPts = NumRows(pts); const int NumVars = NumCols(pts); const long p = ConvertTo<long>(characteristic(Fp)); FF FFp = FFctor(p); FFselect(FFp); FFelem** points_p = (FFelem**)malloc(NumPts*sizeof(FFelem*)); for (int i=0; i < NumPts; ++i) { points_p[i] = (FFelem*)malloc(NumVars*sizeof(FFelem)); for (int j=0; j < NumVars; ++j) { points_p[i][j] = ConvertTo<FFelem>(LeastNNegRemainder(ConvertTo<BigInt>(pts(i,j)), p)); } } pp_cmp_PPM = &PPM(P); const BM modp = BM_affine_mod_p(NumVars, NumPts, points_p, pp_cmp); if (modp == NULL) return std::vector<RingElem>(); // empty list means error const int GBsize = modp->GBsize; std::vector<RingElem> GB(GBsize); vector<long> expv(NumVars); for (int i=0; i < GBsize; ++i) { for (int var = 0; var < NumVars; ++var) expv[var] = modp->pp[modp->GB[i]][var]; RingElem GBelem = monomial(P, 1, expv); for (int j=0; j < NumPts; ++j) { const int c = modp->M[modp->GB[i]][j+NumPts]; if (c == 0) continue; for (int var = 0; var < NumVars; ++var) expv[var] = modp->pp[modp->sep[j]][var]; GBelem += monomial(P, c, expv); } GB[i] = GBelem; } BM_dtor(modp); return GB; }
std::vector<RingElem> BM_QQ(const SparsePolyRing& P, const ConstMatrixView& pts_in) { const long NumPts = NumRows(pts_in); const long dim = NumCols(pts_in); matrix pts = NewDenseMat(RingQQ(), NumPts, dim); for (long i=0; i < NumPts; ++i) for (long j=0; j < dim; ++j) { BigRat q; if (!IsRational(q, pts_in(i,j))) throw 999; SetEntry(pts,i,j, q); } // Ensure input pts have integer coords by using // scale factors for each indet. vector<BigInt> ScaleFactor(dim, BigInt(1)); for (long j=0; j < dim; ++j) for (long i=0; i < NumPts; ++i) ScaleFactor[j] = lcm(ScaleFactor[j], ConvertTo<BigInt>(den(pts(i,j)))); mpz_t **points = (mpz_t**)malloc(NumPts*sizeof(mpz_t*)); for (long i=0; i < NumPts; ++i) { points[i] = (mpz_t*)malloc(dim*sizeof(mpz_t)); for (long j=0; j < dim; ++j) mpz_init(points[i][j]); for (long j=0; j < dim; ++j) { mpz_set(points[i][j], mpzref(ConvertTo<BigInt>(ScaleFactor[j]*pts(i,j)))); } } BMGB char0; // these will be "filled in" by BM_affine below BM modp; // pp_cmp_PPM = &PPM(P); // not threadsafe! BM_affine(&char0, &modp, dim, NumPts, points, pp_cmp); // THIS CALL DOES THE REAL WORK!!! pp_cmp_PPM = NULL; for (long i=NumPts-1; i >=0 ; --i) { for (long j=0; j < dim; ++j) mpz_clear(points[i][j]); free(points[i]); } free(points); if (modp == NULL) { if (char0 != NULL) BMGB_dtor(char0); CoCoA_ERROR("Something went wrong", "BM_QQ"); } // Now extract the answer... const int GBsize = char0->GBsize; std::vector<RingElem> GB(GBsize); const long NumVars = dim; vector<long> expv(NumVars); // buffer for creating monomials for (int i=0; i < GBsize; ++i) { BigInt denom(1); // scale factor needed to make GB elem monic. for (int var = 0; var < NumVars; ++var) { expv[var] = modp->pp[modp->GB[i]][var]; denom *= power(ScaleFactor[var], expv[var]); } RingElem GBelem = monomial(P, 1, expv); for (int j=0; j < NumPts; ++j) { if (mpq_sgn(char0->GB[i][j])==0) continue; BigRat c(char0->GB[i][j]); for (int var = 0; var < NumVars; ++var) { expv[var] = modp->pp[modp->sep[j]][var]; c *= power(ScaleFactor[var], expv[var]); } GBelem += monomial(P, c/denom, expv); } GB[i] = GBelem; } BMGB_dtor(char0); BM_dtor(modp); return GB; // ignoring separators for the moment }
// Not efficient, efficiency not needed at the moment RingElem Facet2RingElem(const SparsePolyRing& theP,const DynamicBitset& b) { return monomial(theP, 1, NewPP(PPM(theP), b)); }//Facet2RingElem
/*! \brief Main function. Execution starts here. * * \retval 42 Fatal error. */ int main(void) { uint32_t iter=0; uint32_t cs2200_out_freq=11289600; static bool b_sweep_up=true; static uint32_t freq_step=0; // USART options. static usart_serial_options_t USART_SERIAL_OPTIONS = { .baudrate = USART_SERIAL_EXAMPLE_BAUDRATE, .charlength = USART_SERIAL_CHAR_LENGTH, .paritytype = USART_SERIAL_PARITY, .stopbits = USART_SERIAL_STOP_BIT }; // Initialize the TWI using the internal RCOSC init_twi(AVR32_PM_RCOSC_FREQUENCY); // Initialize the CS2200 and produce a default frequency. cs2200_setup(11289600, FOSC0); sysclk_init(); // Initialize the board. // The board-specific conf_board.h file contains the configuration of the board // initialization. board_init(); // Initialize the TWI init_twi(sysclk_get_pba_hz()); // Initialize Serial Interface using Stdio Library stdio_serial_init(USART_SERIAL_EXAMPLE,&USART_SERIAL_OPTIONS); // Initialize the HMatrix. init_hmatrix(); print_dbg("\r\nCS2200 Example\r\n"); // Generate a 12.288 MHz frequency out of the CS2200. print_dbg("Output 12.288 MHz\r\n"); cs2200_freq_clk_out(_32_BITS_RATIO(12288000, FOSC0)); cpu_delay_ms( 10000, sysclk_get_cpu_hz()); // Generate a 11.2896 MHz frequency out of the CS2200. print_dbg("Output 11.2896 MHz\r\n"); cs2200_freq_clk_out(_32_BITS_RATIO(cs2200_out_freq, FOSC0)); cpu_delay_ms( 10000, sysclk_get_cpu_hz()); print_dbg("Sweep from 11.2896 MHz steps of 100 PPM\r\n"); freq_step = PPM(cs2200_out_freq, 100); while(1) { uint32_t ratio; if(b_sweep_up) { if( iter<=10 ) { print_dbg("Add 100 PPM\r\n"); iter++; cs2200_out_freq += freq_step; ratio = _32_BITS_RATIO(cs2200_out_freq, FOSC0); cs2200_freq_clk_adjust((uint16_t)ratio); cpu_delay_ms( 1000, sysclk_get_cpu_hz()); while( twi_is_busy() ); } else b_sweep_up=false; } if(!b_sweep_up) { if( iter>0 ) { print_dbg("Sub 100 PPM\r\n"); iter--; cs2200_out_freq -= freq_step; ratio = _32_BITS_RATIO(cs2200_out_freq, FOSC0); cs2200_freq_clk_adjust((uint16_t)ratio); cpu_delay_ms( 1000, sysclk_get_cpu_hz()); while( twi_is_busy() ); } else b_sweep_up=true; } } }
int CameraHal::CapturePicture() { int image_width, image_height, preview_width, preview_height; unsigned long base, offset; struct v4l2_buffer buffer; // for VIDIOC_QUERYBUF and VIDIOC_QBUF struct v4l2_format format; struct v4l2_buffer cfilledbuffer; // for VIDIOC_DQBUF struct v4l2_requestbuffers creqbuf; // for VIDIOC_REQBUFS and VIDIOC_STREAMON and VIDIOC_STREAMOFF sp<MemoryBase> mPictureBuffer; sp<MemoryBase> mFinalPictureBuffer; sp<MemoryHeapBase> mJPEGPictureHeap; sp<MemoryBase> mJPEGPictureMemBase; #if OMAP_SCALE sp<MemoryHeapBase> TempHeapBase; sp<MemoryBase> TempBase; sp<IMemoryHeap> TempHeap; #endif ssize_t newoffset; size_t newsize; mCaptureFlag = true; int jpegSize; void* outBuffer; int err, i; int err_cnt = 0; int EXIF_Data_Size = 0; int ThumbNail_Data_Size = 0; unsigned char* pExifBuf = new unsigned char[65536]; //64*1024 int twoSecondReviewMode = getTwoSecondReviewMode(); int orientation = getOrientation(); LOG_FUNCTION_NAME if (CameraSetFrameRate()) { LOGE("Error in setting Camera frame rate\n"); return -1; } HAL_PRINT("\n\n\n PICTURE NUMBER =%d\n\n\n",++pictureNumber); mParameters.getPictureSize(&image_width, &image_height); mParameters.getPreviewSize(&preview_width, &preview_height); HAL_PRINT("Picture Size: Width = %d \t Height = %d\n", image_width, image_height); HAL_PRINT("Preview Size: Width = %d \t Height = %d\n", preview_width, preview_height); #if OPEN_CLOSE_WORKAROUND close(camera_device); camera_device = open(VIDEO_DEVICE, O_RDWR); if (camera_device < 0) { LOGE ("!!!!!!!!!FATAL Error: Could not open the camera device: %s!!!!!!!!!\n", strerror(errno) ); } #endif if(mCamera_Mode == CAMERA_MODE_JPEG) { int jpeg_width = GetJPEG_Capture_Width(); int jpeg_height = GetJPEG_Capture_Height(); capture_len = jpeg_width * jpeg_height * 2; } else { capture_len = image_width * image_height * 2; } if (capture_len & 0xfff) { capture_len = (capture_len & 0xfffff000) + 0x1000; } HAL_PRINT("pictureFrameSize = 0x%x = %d\n", capture_len, capture_len); mPictureHeap = new MemoryHeapBase(capture_len); base = (unsigned long)mPictureHeap->getBase(); base = (base + 0xfff) & 0xfffff000; offset = base - (unsigned long)mPictureHeap->getBase(); /* set size & format of the video image */ format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; format.fmt.pix.width = image_width; format.fmt.pix.height = image_height; if(mCamera_Mode == CAMERA_MODE_JPEG) format.fmt.pix.pixelformat = PIXEL_FORMAT_JPEG; else format.fmt.pix.pixelformat = PIXEL_FORMAT; if (ioctl(camera_device, VIDIOC_S_FMT, &format) < 0) { LOGE ("Failed to set VIDIOC_S_FMT.\n"); return -1; } #if OMAP_SCALE if(mCameraIndex == VGA_CAMERA && mCamMode != VT_MODE) { if(orientation == 0 || orientation == 180) { struct v4l2_control vc; CLEAR(vc); vc.id = V4L2_CID_FLIP; vc.value = CAMERA_FLIP_MIRROR; if (ioctl (camera_device, VIDIOC_S_CTRL, &vc) < 0) { LOGE("V4L2_CID_FLIP fail!\n"); return UNKNOWN_ERROR; } } } #endif /* Shutter CallBack */ if(mMsgEnabled & CAMERA_MSG_SHUTTER) { mNotifyCb(CAMERA_MSG_SHUTTER,0,0,mCallbackCookie); } /* Check if the camera driver can accept 1 buffer */ creqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; creqbuf.memory = V4L2_MEMORY_USERPTR; creqbuf.count = 1; if (ioctl(camera_device, VIDIOC_REQBUFS, &creqbuf) < 0) { LOGE ("VIDIOC_REQBUFS Failed. errno = %d\n", errno); return -1; } buffer.type = creqbuf.type; buffer.memory = creqbuf.memory; buffer.index = 0; if (ioctl(camera_device, VIDIOC_QUERYBUF, &buffer) < 0) { LOGE("VIDIOC_QUERYBUF Failed"); return -1; } buffer.m.userptr = base; mPictureBuffer = new MemoryBase(mPictureHeap, offset, buffer.length); LOGD("Picture Buffer: Base = %p Offset = 0x%x\n", (void *)base, (unsigned int)offset); if (ioctl(camera_device, VIDIOC_QBUF, &buffer) < 0) { LOGE("CAMERA VIDIOC_QBUF Failed"); return -1; } /* turn on streaming */ creqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; if (ioctl(camera_device, VIDIOC_STREAMON, &creqbuf.type) < 0) { LOGE("VIDIOC_STREAMON Failed\n"); return -1; } HAL_PRINT("De-queue the next avaliable buffer\n"); /* De-queue the next avaliable buffer */ cfilledbuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; cfilledbuffer.memory = creqbuf.memory; while (ioctl(camera_device, VIDIOC_DQBUF, &cfilledbuffer) < 0) { LOGE("VIDIOC_DQBUF Failed cnt = %d\n", err_cnt); if(err_cnt++ > 10) { mNotifyCb(CAMERA_MSG_ERROR,CAMERA_DEVICE_ERROR_FOR_RESTART,0,mCallbackCookie); mPictureBuffer.clear(); mPictureHeap.clear(); return NO_ERROR; } } #if TIMECHECK PPM("AFTER CAPTURE YUV IMAGE\n"); #endif /* turn off streaming */ creqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; if (ioctl(camera_device, VIDIOC_STREAMOFF, &creqbuf.type) < 0) { LOGE("VIDIOC_STREAMON Failed\n"); return -1; } #if OMAP_SCALE if(mCameraIndex == VGA_CAMERA && mCamMode != VT_MODE) { if(orientation == 0 || orientation == 180) { struct v4l2_control vc; CLEAR(vc); vc.id = V4L2_CID_FLIP; vc.value = CAMERA_FLIP_NONE; if (ioctl (camera_device, VIDIOC_S_CTRL, &vc) < 0) { LOGE("V4L2_CID_FLIP fail!\n"); return UNKNOWN_ERROR; } } } #endif if(mCamera_Mode == CAMERA_MODE_JPEG) { int JPEG_Image_Size = GetJpegImageSize(); int thumbNailOffset = GetThumbNailOffset(); int yuvOffset = GetYUVOffset(); ThumbNail_Data_Size = GetThumbNailDataSize(); sp<IMemoryHeap> heap = mPictureBuffer->getMemory(&newoffset, &newsize); uint8_t* pInJPEGDataBUuf = (uint8_t *)heap->base() + newoffset ; uint8_t* pInThumbNailDataBuf = (uint8_t *)heap->base() + thumbNailOffset; uint8_t* pYUVDataBuf = (uint8_t *)heap->base() + yuvOffset; CreateExif(pInThumbNailDataBuf,ThumbNail_Data_Size,pExifBuf,EXIF_Data_Size,1); //create a new binder object mFinalPictureHeap = new MemoryHeapBase(EXIF_Data_Size+JPEG_Image_Size); mFinalPictureBuffer = new MemoryBase(mFinalPictureHeap,0,EXIF_Data_Size+JPEG_Image_Size); heap = mFinalPictureBuffer->getMemory(&newoffset, &newsize); uint8_t* pOutFinalJpegDataBuf = (uint8_t *)heap->base(); //create a new binder obj to send yuv data if(yuvOffset) { int mFrameSizeConvert = (preview_width*preview_height*3/2) ; mYUVPictureHeap = new MemoryHeapBase(mFrameSizeConvert); mYUVPictureBuffer = new MemoryBase(mYUVPictureHeap,0,mFrameSizeConvert); sp<IMemoryHeap> newheap = mYUVPictureBuffer->getMemory(&newoffset, &newsize); #if TIMECHECK PPM("YUV COLOR CONVERSION STARTED\n"); #endif Neon_Convert_yuv422_to_NV21((uint8_t *)pYUVDataBuf, (uint8_t *)newheap->base(), mPreviewWidth, mPreviewHeight); #if TIMECHECK PPM("YUV COLOR CONVERSION ENDED\n"); #endif } //create final JPEG with EXIF into that int OutJpegSize = 0; err = CreateJpegWithExif(pInJPEGDataBUuf,JPEG_Image_Size,pExifBuf,EXIF_Data_Size,pOutFinalJpegDataBuf,OutJpegSize); if(err==false) return -1; if(yuvOffset) { #ifdef HARDWARE_OMX if(twoSecondReviewMode == 1) { DrawOverlay(pYUVDataBuf, true); } #endif //HARDWARE_OMX if(mMsgEnabled & CAMERA_MSG_RAW_IMAGE) { mDataCb(CAMERA_MSG_RAW_IMAGE, mYUVPictureBuffer, mCallbackCookie); } } if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) { mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mFinalPictureBuffer, mCallbackCookie); } #if OPEN_CLOSE_WORKAROUND close(camera_device); camera_device = open(VIDEO_DEVICE, O_RDWR); if (camera_device < 0) { LOGE ("!!!!!!!!!FATAL Error: Could not open the camera device: %s!!!!!!!!!\n", strerror(errno) ); } #endif } if(mCamera_Mode == CAMERA_MODE_YUV) { #ifdef HARDWARE_OMX int mFrameSizeConvert = (image_width*image_height*2) ; mVGAYUVPictureHeap = new MemoryHeapBase(mFrameSizeConvert); mVGAYUVPictureBuffer = new MemoryBase(mVGAYUVPictureHeap,0,mFrameSizeConvert); mVGANewheap = mVGAYUVPictureBuffer->getMemory(&newoffset, &newsize); sp<IMemoryHeap> heap = mPictureBuffer->getMemory(&newoffset, &newsize); uint8_t* pYUVDataBuf = (uint8_t *)heap->base() + newoffset ; LOGD("PictureThread: generated a picture, yuv_buffer=%p yuv_len=%d\n",pYUVDataBuf,capture_len); #if OMAP_SCALE TempHeapBase = new MemoryHeapBase(mFrameSizeConvert); TempBase = new MemoryBase(TempHeapBase,0,mFrameSizeConvert); TempHeap = TempBase->getMemory(&newoffset, &newsize); if(scale_process((void*)pYUVDataBuf, mPreviewWidth, mPreviewHeight,(void*)TempHeap->base(), mPreviewHeight, mPreviewWidth, 0, PIX_YUV422I, 1)) { LOGE("scale_process() failed\n"); } #endif #if TIMECHECK PPM("YUV COLOR ROTATION STARTED\n"); #endif #if 0 //YUV dump code for testing FILE* fIn = NULL; fIn = fopen("/data/output.yuv", "w"); if ( fIn == NULL ) { LOGE("Error: failed to open the file for writing\n"); } fwrite((uint8_t*)mVGANewheap->base(), 1, mPreviewWidth*mPreviewHeight*2, fIn); fclose(fIn); #endif /* for VGA capture case pYUVDataBuf : Input buffer from Camera Driver YUV422. mVGANewheap->base() : 90 or 270 degree rotated YUV422 format. */ { int error = 0; #if OMAP_SCALE neon_args->pIn = (uint8_t*)TempHeap->base(); #else neon_args->pIn = (uint8_t*)pYUVDataBuf; #endif neon_args->pOut = (uint8_t*)mVGANewheap->base(); neon_args->height = mPreviewWidth; neon_args->width = mPreviewHeight; #if OMAP_SCALE neon_args->rotate = NEON_ROT90; #else neon_args->rotate = NEON_ROT270; #endif if (Neon_Rotate != NULL) error = (*Neon_Rotate)(neon_args); else LOGE("Rotate Fucntion pointer Null"); if (error < 0) { LOGE("Error in Rotation 90"); } } #if OMAP_SCALE TempHeapBase.clear(); TempBase.clear(); TempHeap.clear(); #endif #if TIMECHECK PPM("YUV COLOR ROTATION Done\n"); #endif #endif //HARDWARE_OMX if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) { #ifdef HARDWARE_OMX int jpegSize = image_width * image_height*2; capture_len = (image_width*image_height*2) ; CreateExif(NULL, 0, pExifBuf, EXIF_Data_Size, 0); HAL_PRINT("VGA EXIF size : %d\n", EXIF_Data_Size); mJPEGPictureHeap = new MemoryHeapBase(jpegSize + 256); outBuffer = (void *)((unsigned long)(mJPEGPictureHeap->getBase()) + 128); #if TIMECHECK PPM("BEFORE JPEG Encode Image\n"); #endif HAL_PRINT("VGA capture : outbuffer = 0x%x, jpegSize = %d, yuv_buffer = 0x%x, yuv_len = %d, image_width = %d, image_height = %d, quality = %d, mippMode =%d\n", outBuffer, jpegSize, yuv_buffer, capture_len, image_width, image_height, mYcbcrQuality, mippMode); if(isStart_JPEG) { int jpegFormat = PIX_YUV422I; #ifdef OMAP_ENHANCEMENT #if OMAP_SCALE err = jpegEncoder->encodeImage(outBuffer, jpegSize, (uint8_t*)mVGANewheap->base(), capture_len, pExifBuf, EXIF_Data_Size, image_width, // image_height, // mThumbnailWidth, mThumbnailHeight, mYcbcrQuality, jpegFormat); #else err = jpegEncoder->encodeImage(outBuffer, jpegSize, (uint8_t*)mVGANewheap->base(), capture_len, pExifBuf, EXIF_Data_Size, image_height, // image_width, // mThumbnailWidth, mThumbnailHeight, mYcbcrQuality, jpegFormat); #endif LOGD("JPEG ENCODE END\n"); if(err != true) { LOGE("Jpeg encode failed!!\n"); return -1; } else { LOGD("Jpeg encode success!!\n"); } #endif } #if TIMECHECK PPM("AFTER JPEG Encode Image\n"); #endif #ifdef OMAP_ENHANCEMENT mJPEGPictureMemBase = new MemoryBase(mJPEGPictureHeap, 128, jpegEncoder->jpegSize); #endif if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) { mDataCb(CAMERA_MSG_COMPRESSED_IMAGE,mJPEGPictureMemBase,mCallbackCookie); } mJPEGPictureMemBase.clear(); mJPEGPictureHeap.clear(); #endif //HARDWARE_OMX }//END of CAMERA_MSG_COMPRESSED_IMAGE yuv_buffer = (uint8_t*)cfilledbuffer.m.userptr; if(twoSecondReviewMode == 1) { DrawOverlay(yuv_buffer, true); } //yuv_buffer: [Reused]Output buffer with YUV 420P 270 degree rotated. if(mMsgEnabled & CAMERA_MSG_RAW_IMAGE) { Neon_Convert_yuv422_to_YUV420P((uint8_t *)mVGANewheap->base(), (uint8_t *)yuv_buffer, mPreviewHeight, mPreviewWidth); mDataCb(CAMERA_MSG_RAW_IMAGE, mPictureBuffer, mCallbackCookie); } } //END of CAMERA_MODE_YUV mPictureBuffer.clear(); mPictureHeap.clear(); if(mCamera_Mode == CAMERA_MODE_JPEG) { mFinalPictureBuffer.clear(); mFinalPictureHeap.clear(); mYUVPictureBuffer.clear(); mYUVPictureHeap.clear(); } if(mCamera_Mode == CAMERA_MODE_YUV) { if(mCameraIndex == VGA_CAMERA) { mVGAYUVPictureBuffer.clear(); mVGAYUVPictureHeap.clear(); } } delete []pExifBuf; mCaptureFlag = false; LOG_FUNCTION_NAME_EXIT return NO_ERROR; }
//! //! @brief This function takes the stream coming from the selected USB pipe and sends //! it to the DAC driver. Moreover, it ensures that both input and output stream //! keep synchronized by adding or deleting samples. //! //! @param side USB_STREAM_HOST for USB host, USB_STREAM_DEVICE for device. //! @param pipe_in Number of the addressed pipe/endpoint //! @param pFifoCount (return parameter) NULL or pointer to the number of used buffers at this time //! //! @return status: (USB_STREAM_STATUS_OK, USB_STREAM_STATUS_NOT_SYNCHRONIZED, //! USB_STREAM_STATUS_SPEED_UP, USB_STREAM_STATUS_SLOW_DOWN, USB_STREAM_STATUS_BUFFER_OVERFLOW) //! int usb_stream_input(usb_stream_side_t side, uint8_t pipe_in, uint32_t* pFifoCount) { uint16_t fifo_used_cnt; uint16_t byte_count=0; uint32_t i; UnionPtr pswap; UnionPtr buffer; // We comes here since we have received something. Let's increase the internal // activity counter. usb_stream_cnt++; fifo_used_cnt=usb_stream_fifo_get_used_room(); if (pFifoCount) *pFifoCount = fifo_used_cnt; // usb_stream_fifo_get_free_room() if( USB_STREAM_BUFFER_NUMBER-fifo_used_cnt==0 ) { // Fatal error: even with the synchro mechanism acting, we are in a case in which the // buffers are full. usb_stream_context->synchronized = false; usb_stream_context->status = USB_STREAM_ERROR_NOT_SYNCHRONIZED; return usb_stream_context->status; } pswap.s8ptr = buffer.s8ptr = usb_stream_fifo_get_buffer(usb_stream_context->wr_id); #if USB_HOST_FEATURE == true if( side==USB_STREAM_HOST ) { byte_count=Host_byte_count(pipe_in); } #endif #if USB_DEVICE_FEATURE == true if( side==USB_STREAM_DEVICE ) { byte_count=Usb_byte_count(pipe_in); } #endif if( byte_count==0 ) { if( cpu_is_timeout(&broken_stream_timer) ) { usb_stream_context->status = USB_STREAM_ERROR_BROKEN_STREAM; } else { usb_stream_context->status = USB_STREAM_ERROR_NO_DATA; } return usb_stream_context->status; } else { // reset time out detection cpu_set_timeout(cpu_ms_2_cy(BROKEN_STREAM_TIMER, FCPU_HZ), &broken_stream_timer); } #if USB_HOST_FEATURE == true if( side==USB_STREAM_HOST ) { Host_reset_pipe_fifo_access(pipe_in); host_read_p_rxpacket(pipe_in, (void*)buffer.s8ptr, byte_count, NULL); } #endif #if USB_DEVICE_FEATURE == true if( side==USB_STREAM_DEVICE ) { Usb_reset_endpoint_fifo_access(pipe_in); usb_read_ep_rxpacket(pipe_in, (void*)buffer.s8ptr, byte_count, NULL); } #endif usb_stream_context->status = USB_STREAM_ERROR_NONE; if( byte_count > USB_STREAM_REAL_BUFFER_SIZE ) { byte_count = USB_STREAM_REAL_BUFFER_SIZE; usb_stream_context->status = USB_STREAM_ERROR_OVERFLOW; } // Swap samples since they are coming from the USB world. if( usb_stream_context->bits_per_sample==16 ) for( i=0 ; i<byte_count/(16/8) ; i++ ) pswap.s16ptr[i] = swap16(pswap.s16ptr[i]); else if( usb_stream_context->bits_per_sample==32 ) for( i=0 ; i<byte_count/(32/8) ; i++ ) pswap.s32ptr[i] = swap32(pswap.s32ptr[i]); //for( i=0 ; i<byte_count/2 ; i++ ) // printf("0x%04hx ", pswap[i]); //printf("\r\n"); usb_stream_fifo_push(byte_count); fifo_used_cnt++; if( !usb_stream_context->synchronized ) { usb_stream_context->status = USB_STREAM_ERROR_NOT_SYNCHRONIZED; if( fifo_used_cnt>=(USB_STREAM_BUFFER_NUMBER/2) ) { // We have enough buffers to start the playback. void* buffer; uint16_t size; // CS2200 cs2200_freq_clk_out(_32_BITS_RATIO(usb_stream_resync_frequency, CS2200_FREF)); usb_stream_resync_step = PPM(usb_stream_resync_frequency, USB_STREAM_RESYNC_PPM_STEPS); usb_stream_resync_freq_ofst = usb_stream_resync_frequency; usb_stream_resync_ppm_ofst = 0; usb_stream_resync_last_room = fifo_used_cnt; #define TIMER_USB_RESYNC_CORRECTION 320 cpu_set_timeout( cpu_ms_2_cy(TIMER_USB_RESYNC_CORRECTION, FCPU_HZ), &usb_resync_timer ); usb_stream_context->synchronized=true; usb_stream_fifo_get(&buffer, &size); audio_mixer_dacs_output_direct(buffer, size/(usb_stream_context->channel_count*usb_stream_context->bits_per_sample/8)); // Fill also the reload stage of the PDCA. usb_stream_fifo_pull(); usb_stream_fifo_get(&buffer, &size); audio_mixer_dacs_output_direct(buffer, size/(usb_stream_context->channel_count*usb_stream_context->bits_per_sample/8)); } } return usb_stream_context->status; }
int CameraHal::CapturePicture() { int image_width, image_height, preview_width, preview_height; int capture_len; unsigned long base, offset; #ifdef R3D4_CONVERT CColorConvert* pConvert; //class for image processing #endif struct v4l2_buffer buffer; // for VIDIOC_QUERYBUF and VIDIOC_QBUF struct v4l2_format format; //struct v4l2_buffer cfilledbuffer; // for VIDIOC_DQBUF struct v4l2_requestbuffers creqbuf; // for VIDIOC_REQBUFS and VIDIOC_STREAMON and VIDIOC_STREAMOFF sp<MemoryBase> mPictureBuffer; sp<MemoryBase> mFinalPictureBuffer; sp<MemoryHeapBase> mJPEGPictureHeap; sp<MemoryBase> mJPEGPictureMemBase; ssize_t newoffset; size_t newsize; mCaptureFlag = true; int jpegSize; void* outBuffer; int err, i; int err_cnt = 0; int exifDataSize = 0; int thumbnaiDataSize = 0; unsigned char* pExifBuf = new unsigned char[64*1024]; int twoSecondReviewMode = getTwoSecondReviewMode(); int orientation = getOrientation(); LOG_FUNCTION_NAME if (CameraSetFrameRate()) { LOGE("Error in setting Camera frame rate\n"); return -1; } LOGD("\n\n\n PICTURE NUMBER =%d\n\n\n",++pictureNumber); mParameters.getPictureSize(&image_width, &image_height); mParameters.getPreviewSize(&preview_width, &preview_height); LOGV("mCameraIndex = %d\n", mCameraIndex); LOGD("Picture Size: Width = %d \t Height = %d\n", image_width, image_height); /* set size & format of the video image */ format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; format.fmt.pix.width = image_width; format.fmt.pix.height = image_height; if(mCamera_Mode == CAMERA_MODE_JPEG) { format.fmt.pix.pixelformat = PIXEL_FORMAT_JPEG; capture_len = GetJPEG_Capture_Width() * GetJPEG_Capture_Height() * JPG_BYTES_PER_PIXEL; } else { format.fmt.pix.pixelformat = PIXEL_FORMAT; capture_len = image_width * image_height * UYV_BYTES_PER_PIXEL; } // round up to 4096 bytes if (capture_len & 0xfff) capture_len = (capture_len & 0xfffff000) + 0x1000; LOGV("capture: %s mode, pictureFrameSize = 0x%x = %d\n", (mCamera_Mode == CAMERA_MODE_JPEG)?"jpeg":"yuv", capture_len, capture_len); mPictureHeap = new MemoryHeapBase(capture_len); base = (unsigned long)mPictureHeap->getBase(); base = (base + 0xfff) & 0xfffff000; offset = base - (unsigned long)mPictureHeap->getBase(); // set capture format if (ioctl(camera_device, VIDIOC_S_FMT, &format) < 0) { LOGE ("Failed to set VIDIOC_S_FMT.\n"); return -1; } #if OMAP_SCALE if(mCameraIndex == VGA_CAMERA && mCamMode != VT_MODE) if(orientation == 0 || orientation == 180) setFlip(CAMERA_FLIP_MIRROR); #endif /* Shutter CallBack */ if(mMsgEnabled & CAMERA_MSG_SHUTTER) { mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie); } /* Check if the camera driver can accept 1 buffer */ creqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; creqbuf.memory = V4L2_MEMORY_USERPTR; creqbuf.count = 1; if (ioctl(camera_device, VIDIOC_REQBUFS, &creqbuf) < 0) { LOGE ("VIDIOC_REQBUFS Failed. errno = %d\n", errno); return -1; } buffer.type = creqbuf.type; buffer.memory = creqbuf.memory; buffer.index = 0; if (ioctl(camera_device, VIDIOC_QUERYBUF, &buffer) < 0) { LOGE("VIDIOC_QUERYBUF Failed"); return -1; } buffer.m.userptr = base; mPictureBuffer = new MemoryBase(mPictureHeap, offset, buffer.length); LOGD("Picture Buffer: Base = %p Offset = 0x%x\n", (void *)base, (unsigned int)offset); if (ioctl(camera_device, VIDIOC_QBUF, &buffer) < 0) { LOGE("CAMERA VIDIOC_QBUF Failed"); return -1; } /* turn on streaming */ if (ioctl(camera_device, VIDIOC_STREAMON, &creqbuf.type) < 0) { LOGE("VIDIOC_STREAMON Failed\n"); return -1; } LOGD("De-queue the next avaliable buffer\n"); /* De-queue the next avaliable buffer */ //try to get buffer from camearo for 10 times while (ioctl(camera_device, VIDIOC_DQBUF, &buffer) < 0) { LOGE("VIDIOC_DQBUF Failed cnt = %d\n", err_cnt); if(err_cnt++ > 10) { mNotifyCb(CAMERA_MSG_ERROR, CAMERA_DEVICE_ERROR_FOR_RESTART, 0, mCallbackCookie); mPictureBuffer.clear(); mPictureHeap.clear(); return NO_ERROR; } } PPM("AFTER CAPTURE YUV IMAGE\n"); /* turn off streaming */ if (ioctl(camera_device, VIDIOC_STREAMOFF, &creqbuf.type) < 0) { LOGE("VIDIOC_STREAMON Failed\n"); return -1; } #if OMAP_SCALE if(mCameraIndex == VGA_CAMERA && mCamMode != VT_MODE) if(orientation == 0 || orientation == 180) setFlip(CAMERA_FLIP_NONE); #endif // camera returns processed jpeg image if(mCamera_Mode == CAMERA_MODE_JPEG) { int JPEG_Image_Size = GetJpegImageSize(); int thumbNailOffset = 0; //m4mo doesnt store offset ? int yuvOffset =0; //m4mo doesnt store yuv image ? // int thumbNailOffset = GetThumbNailOffset(); // int yuvOffset = GetYUVOffset(); thumbnaiDataSize = GetThumbNailDataSize(); sp<IMemoryHeap> heap = mPictureBuffer->getMemory(&newoffset, &newsize); uint8_t* pInJPEGDataBUuf = (uint8_t *)heap->base() + newoffset ; //ptr to jpeg data uint8_t* pInThumbNailDataBuf = (uint8_t *)heap->base() + thumbNailOffset; //ptr to thmubnail uint8_t* pYUVDataBuf = (uint8_t *)heap->base() + yuvOffset; // FILE* fOut = NULL; // fOut = fopen("/dump/dump.jpg", "w"); // fwrite(pInJPEGDataBUuf, 1, JPEG_Image_Size, fOut); // fclose(fOut); CreateExif(pInThumbNailDataBuf, thumbnaiDataSize, pExifBuf, exifDataSize, EXIF_SET_JPEG_LENGTH); //create a new binder object mFinalPictureHeap = new MemoryHeapBase(exifDataSize+JPEG_Image_Size); mFinalPictureBuffer = new MemoryBase(mFinalPictureHeap,0,exifDataSize+JPEG_Image_Size); heap = mFinalPictureBuffer->getMemory(&newoffset, &newsize); uint8_t* pOutFinalJpegDataBuf = (uint8_t *)heap->base(); //create a new binder obj to send yuv data if(yuvOffset) { int mFrameSizeConvert = (preview_width*preview_height*3/2) ; mYUVPictureHeap = new MemoryHeapBase(mFrameSizeConvert); mYUVPictureBuffer = new MemoryBase(mYUVPictureHeap,0,mFrameSizeConvert); mYUVNewheap = mYUVPictureBuffer->getMemory(&newoffset, &newsize); PPM("YUV COLOR CONVERSION STARTED\n"); #ifdef NEON Neon_Convert_yuv422_to_NV21((uint8_t *)pYUVDataBuf, (uint8_t *)mYUVNewheap->base(), mPreviewWidth, mPreviewHeight); PPM("YUV COLOR CONVERSION ENDED\n"); if(mMsgEnabled & CAMERA_MSG_RAW_IMAGE) { mDataCb(CAMERA_MSG_RAW_IMAGE, mYUVPictureBuffer, mCallbackCookie); } #else if(mMsgEnabled & CAMERA_MSG_RAW_IMAGE) mDataCb(CAMERA_MSG_RAW_IMAGE, pYUVDataBuf, mCallbackCookie); #endif } //create final JPEG with EXIF into that int OutJpegSize = 0; if(!CreateJpegWithExif( pInJPEGDataBUuf, JPEG_Image_Size, pExifBuf, exifDataSize, pOutFinalJpegDataBuf, OutJpegSize)) { LOGE("createJpegWithExif fail!!\n"); return -1; } if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) { mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mFinalPictureBuffer, mCallbackCookie); } } //CAMERA_MODE_JPEG // camera returns 16 bit uyv image // -> needs to process (rotate/flip) // -> and compess to jpeg (with dsp) if(mCamera_Mode == CAMERA_MODE_YUV) { #ifdef HARDWARE_OMX // create new buffer for image processing int mFrameSizeConvert = (image_width*image_height*2) ; mYUVPictureHeap = new MemoryHeapBase(mFrameSizeConvert); mYUVPictureBuffer = new MemoryBase(mYUVPictureHeap,0,mFrameSizeConvert); mYUVNewheap = mYUVPictureBuffer->getMemory(&newoffset, &newsize); // buffer from v4l holding the actual image uint8_t *pYuvBuffer = (uint8_t*)buffer.m.userptr; LOGD("PictureThread: generated a picture, pYuvBuffer=%p yuv_len=%d\n", pYuvBuffer, capture_len); PPM("YUV COLOR ROTATION STARTED\n"); #ifdef R3D4_CONVERT if(mCameraIndex == VGA_CAMERA) { LOGV("use rotation"); // color converter and image processing (flip/rotate) // neon lib doesnt seem to work, jpeg was corrupted? // so use own stuff pConvert = new CColorConvert(pYuvBuffer, image_width, image_height, UYV2); //pConvert->writeFile(DUMP_PATH "before_rotate.uyv", SOURCE); //pConvert->writeFile(DUMP_PATH "before_rotate.bmp", BMP); if(mCameraIndex == VGA_CAMERA ) pConvert->rotateImage(ROTATE_270); // else // pConvert->flipImage(FLIP_VERTICAL); // write rotatet image back to input buffer //pConvert->writeFile(DUMP_PATH "after_rotate.bmp", BMP); pConvert->makeUYV2(NULL, INPLACE); //INPLACE: no new buffer, write to input buffer image_width = pConvert->getWidth(); image_height = pConvert->geHeight(); } #else #endif PPM("YUV COLOR ROTATION Done\n"); //pYuvBuffer: [Reused]Output buffer with YUV 420P 270 degree rotated. if(mMsgEnabled & CAMERA_MSG_RAW_IMAGE) { // convert pYuvBuffer(YUV422I) to mYUVPictureBuffer(YUV420P) Neon_Convert_yuv422_to_YUV420P(pYuvBuffer, (uint8_t *)mYUVNewheap->base(), image_width, image_height); mDataCb(CAMERA_MSG_RAW_IMAGE, mYUVPictureBuffer, mCallbackCookie); } #endif //HARDWARE_OMX if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) { #ifdef HARDWARE_OMX // int inputFormat = PIX_YUV420P; // int imputSize = image_width * image_height * PIX_YUV420P_BYTES_PER_PIXEL; int inputFormat = PIX_YUV422I; int inputSize = image_width * image_height * PIX_YUV422I_BYTES_PER_PIXEL; int jpegSize = image_width * image_height * JPG_BYTES_PER_PIXEL; CreateExif(NULL, 0, pExifBuf, exifDataSize, EXIF_NOTSET_JPEG_LENGTH); HAL_PRINT("VGA EXIF size : %d\n", exifDataSize); mJPEGPictureHeap = new MemoryHeapBase(jpegSize + 256); outBuffer = (void *)((unsigned long)(mJPEGPictureHeap->getBase()) + 128); HAL_PRINT("YUV capture : outbuffer = 0x%x, jpegSize = %d, pYuvBuffer = 0x%x, yuv_len = %d, image_width = %d, image_height = %d, quality = %d, mippMode =%d\n", outBuffer, jpegSize, pYuvBuffer, capture_len, image_width, image_height, mYcbcrQuality, mippMode); if(jpegEncoder) { PPM("BEFORE JPEG Encode Image\n"); err = jpegEncoder->encodeImage( outBuffer, // void* outputBuffer, jpegSize, // int outBuffSize, pYuvBuffer, // void *inputBuffer, inputSize, // int inBuffSize, pExifBuf, // unsigned char* pExifBuf, exifDataSize, // int ExifSize, image_width, // int width, image_height, // int height, mThumbnailWidth, // int ThumbWidth, mThumbnailHeight, // int ThumbHeight, mYcbcrQuality, // int quality, inputFormat); // int isPixelFmt420p) PPM("AFTER JPEG Encode Image\n"); LOGD("JPEG ENCODE END\n"); if(err != true) { LOGE("Jpeg encode failed!!\n"); return -1; } else LOGD("Jpeg encode success!!\n"); } mJPEGPictureMemBase = new MemoryBase(mJPEGPictureHeap, 128, jpegEncoder->jpegSize); if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) { mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mJPEGPictureMemBase, mCallbackCookie); } mJPEGPictureMemBase.clear(); mJPEGPictureHeap.clear(); #endif //HARDWARE_OMX }//END of CAMERA_MSG_COMPRESSED_IMAGE #ifdef R3D4_CONVERT delete pConvert; #endif }//END of CAMERA_MODE_YUV mPictureBuffer.clear(); mPictureHeap.clear(); if(mCamera_Mode == CAMERA_MODE_JPEG) { mFinalPictureBuffer.clear(); mFinalPictureHeap.clear(); } mYUVPictureBuffer.clear(); mYUVPictureHeap.clear(); delete []pExifBuf; mCaptureFlag = false; LOG_FUNCTION_NAME_EXIT return NO_ERROR; }
static void mix_MultiPosition(u8 action) { s8 val; if (action == MLA_CHG) { // change value if (menu_set == 0) { // channel number/off val = cm.channel_MP; if (!val) val = 2; else if (val == MP_DIG) val = (s8)(channels + 1); val = (u8)menu_change_val(val, 2, channels + 1, 1, 1); if (val == 2) cm.channel_MP = 0; else if (val == (s8)(channels + 1)) cm.channel_MP = MP_DIG; else cm.channel_MP = val; } else { // position value + END state (END not for first position) val = cm.multi_position[menu_set - 1]; if (val == MULTI_POSITION_END) val = -101; val = (s8)menu_change_val(val, menu_set == 1 ? -100 : -101, 100, CHANNEL_FAST, 0); if (val == -101) { // set all from this to END value memset(&cm.multi_position[menu_set - 1], (u8)MULTI_POSITION_END, NUM_MULTI_POSITION + 1 - menu_set); } else cm.multi_position[menu_set - 1] = val; } } else if (action == MLA_NEXT) { // select next value if (cm.channel_MP) { if (menu_set == 0) menu_set = 1; else if (cm.multi_position[menu_set - 1] == MULTI_POSITION_END || ++menu_set > NUM_MULTI_POSITION) menu_set = 0; } // allow forcing channel value if (menu_set && cm.channel_MP && cm.channel_MP <= channels) { menu_force_value_channel = cm.channel_MP; } else menu_force_value_channel = 0; } // show value lcd_7seg(L7_P); if (menu_set == 0) { // channel number/OFF if (!cm.channel_MP) lcd_chars("OFF"); else if (cm.channel_MP == MP_DIG) lcd_chars("DIG"); else lcd_char_num3(cm.channel_MP); lcd_segment(LS_SYM_CHANNEL, LS_ON); } else { // position value val = cm.multi_position[menu_set - 1]; if (val == MULTI_POSITION_END) { lcd_chars("END"); val = -100; } else lcd_char_num3(val); if (cm.channel_MP == MP_DIG) menu_DIG_mix = val; else menu_force_value = val * PPM(5); } }