jpeg_encode.c

这个是balckfin533/561的MPEG和Mjpeg的源代码

			}   
			else if (File_Settings == GET_FILE_SETTINGS_FROM_TXT_FILE) 
			{
				// Get Next File name from directory file
				next_file = fscanf(fp_jpg_dir, "%s %d %d %d", current_input_file_name, &JPEGImageWidth, &JPEGImageHeight, &QualityFactor);				
			}
		}
		// free up Video and DMA resources	
		// Free MDMA stream used for ITU656 to YUV conversion
		FreeMDMA_YUV_ITU656 ();		
		// Close Video Decoder (ADV7183)
		ezErrorCheck(adi_dev_Close(ADV7183DeviceHandle));			
	}

	if(return_code)
		fprintf(fperr, "\n!!! JPEG Encoding Failed !!!\n");
		
	if (File_Settings == GET_FILE_SETTINGS_FROM_TXT_FILE)
	{
	    printf("Reached end of list\n");
		// close the list file
		fclose( fp_jpg_dir );
	}

  	return return_code;
}

/*********************************************************************

    Function:       JPEG_encode

    Description:    Encodes a ITU656 frame to JPEG image 
    				(by interacting with JPEG Encode library)

*********************************************************************/	
section("sdram0_bank1_cache")
int JPEG_encode(char* input_file)
{
	tJpegEncoder	   			*lBaseJpegEnc = NULL;
	tJpegParam		   			lImageEncParam = { 0 };
	uint8	        			*lOutputBuffer;       	// Image output buffer	
	MemObjHandle      			*StreamBuffer_Obj;
	uint8			  			*StreamBuffer = NULL;
	FILE			   			*OutputFile = NULL;		// Image output file	
	uint32			 			NumBytes = 0;
    int32 				    	lResult = 0;

#ifdef ADI_MMSK_EXTRA_INFO		// macto to enable extra debug information
	// cycle counting
	static cycle_t              start_count;
	static cycle_t              final_count;
#endif
	
    // Get the address of YUV output buffer
	lOutputBuffer = (uint8*)pYUVBufs[0];
	
	printf("\npress and release button %s on EZ-kit to capture a frame\n",JPEG_MJPEG_REC_BUTTON_ID);
					
	// wait for button to be pressed
	while(!ezIsButtonPushed(JPEG_MJPEG_RECORD_BUTTON));
	// wait for button to be released
	while(ezIsButtonPushed(JPEG_MJPEG_RECORD_BUTTON));
	
	// Get the input video mode & update the video parameters
	UpdateInputVideoMode();
	// Submit Video Input buffer for JPEG encoding (only one ITU656 frame buffer will be used)
	SubmitVideoInBufs ();
	
	// wait until a video frame is captured		
	VideoFrameCompletedFlag = FALSE;	
	while(VideoFrameCompletedFlag != TRUE)
		asm("nop;");	
	VideoFrameCompletedFlag = FALSE;	
	    	
	// Initialise ITU656 to YUV conversion parameters
 	// Source Descriptor start address - Video (ITU656) buffer(s)
 	pSrcDescStartAddr	= pITU656Frames[0];
 	// Destination Descriptor start buffer - YUV buffer(s)
 	pDestDescStartAddr	= pYUVBufs[0];

	// check interleave format
	if (JPEGFrameFormat == 1)
	{
	    // Image will be encoded in YUV420 format
	    // initialise MDMA descriptors for ITU656 to YUV420 conversion
	    SetupMDMA_ITU656toYUV420 ();
	}
			
	// Kick off the DMA transfer (build YUV buffer from ITU656 frame)
	FrameReady = FALSE;	
	KickOffMDMA_YUV_ITU656();		
	// wait until YUV frame is ready
	while(!FrameReady)
		asm("nop;");

	// now we have the YUV buffers filled with an image
	// Configure JPEG encoder
	// set the desired input image width
	lResult = JPEG_Param_CONFIG(&lImageEncParam, JPEG_FRAME_WIDTH, JPEGImageWidth);
	if(lResult != E_SUCCESS)	JPEG_ProcessErrorCode(lResult, "JPEG_Param_CONFIG");
    // set the desired input image height
	lResult = JPEG_Param_CONFIG(&lImageEncParam, JPEG_FRAME_HEIGHT, JPEGImageHeight);
	if(lResult != E_SUCCESS)	JPEG_ProcessErrorCode(lResult, "JPEG_Param_CONFIG");
    // set the desired Quality factor
	lResult = JPEG_Param_CONFIG(&lImageEncParam, JPEG_QUALITYFACTOR, QualityFactor);
	if(lResult != E_SUCCESS)	JPEG_ProcessErrorCode(lResult, "JPEG_Param_CONFIG");
	// set the desired encoding mode
	lResult = JPEG_Param_CONFIG(&lImageEncParam, JPEG_ENCODINGMODE, EncodingMode);
	if(lResult != E_SUCCESS)	JPEG_ProcessErrorCode(lResult, "JPEG_Param_CONFIG");
	// set the desired threshold
	lResult = JPEG_Param_CONFIG(&lImageEncParam, JPEG_THRESHOLD, Threshold);
	if(lResult != E_SUCCESS)	JPEG_ProcessErrorCode(lResult, "JPEG_Param_CONFIG");
	// set the desired image frame format
	lResult = JPEG_Param_CONFIG(&lImageEncParam, JPEG_IMAGEFORMAT, JPEGFrameFormat);
	if(lResult != E_SUCCESS)    JPEG_ProcessErrorCode(lResult, "JPEG_Param_CONFIG");
	
	// allocate the output streambuffer
	StreamBuffer_Obj = JPEG_MemAlloc_NEW(3 * JPEGImageWidth * JPEGImageHeight,1,MEM_TYPE_DATA);
	if(StreamBuffer_Obj == NULL)
	{
		fprintf(fperr, "Memory allocation for StreamBuffer failed.\n");
		return CODEC_MEMORY_ALLOCATION_ERROR;	
	}
	
	// Get address of the output stream buffer
	StreamBuffer = (uint8*)JPEG_MemAlloc_ADDRESS(StreamBuffer_Obj);

	// pass input buffer address
	lResult = JPEG_Param_CONFIG(&lImageEncParam, JPEG_POINTER_INPUT, (int)lOutputBuffer);
	if(lResult != E_SUCCESS)	JPEG_ProcessErrorCode(lResult, "JPEG_Param_CONFIG");

    // pass output buffer address 
	lResult = JPEG_Param_CONFIG(&lImageEncParam, JPEG_POINTER_OUTPUT, (int)StreamBuffer);
	if(lResult != E_SUCCESS)	JPEG_ProcessErrorCode(lResult, "JPEG_Param_CONFIG");

	// Create Instance of JPEG Encoder
	lBaseJpegEnc = JPEG_Encoder_NEW(&lImageEncParam);
	// check if the encoder instance creation was a success
	if(lBaseJpegEnc == NULL)
	{
		fprintf(fperr, "Encoder creation failed\n");
		// free the memory
		JPEG_MemAlloc_DELETE(StreamBuffer_Obj);
		return CODEC_MEMORY_ALLOCATION_ERROR;
	}

#ifdef ADI_MMSK_EXTRA_INFO		// macro to enable extra debug information    	
	START_CYCLE_COUNT(start_count)	// begin counting time
#endif

	// Encode the YUV frame to JPEG image
	lResult = JPEG_EncodeImage(lBaseJpegEnc, &NumBytes);	
	
#ifdef ADI_MMSK_EXTRA_INFO		// Extra debug information
	STOP_CYCLE_COUNT(final_count,start_count)	// stop counting
#endif // ADI_MMSK_EXTRA_INFO	

	// process the encode image result
	if (lResult != E_SUCCESS)
	{
	    JPEG_ProcessErrorCode(lResult, "JPEG_EncodeImage");
	    fprintf(fperr, "!!! JPEG Encoding process failed!!!\n");
		// free the memory
		JPEG_MemAlloc_DELETE(StreamBuffer_Obj);		
		// Delete Encoder instance
		JPEG_Encoder_DELETE(lBaseJpegEnc);
		return CODEC_ALGORITHM_ERROR;
	}
		
#ifdef ADI_MMSK_EXTRA_INFO		// Extra debug information
	printf("\nTook %lu cycles to encode this image, ",final_count);
	printf("Equivalent to %lu cyles/pixel\n", final_count/((JPEGImageWidth) * (JPEGImageHeight)));
#endif // ADI_MMSK_EXTRA_INFO
	
	// Delete Encoder instance
	JPEG_Encoder_DELETE(lBaseJpegEnc);

	// check for file extension. add file extension if user didn't provide it
	if ((strstr(input_file, ".jpg") == NULL) &&	(strstr(input_file, ".JPG") == NULL))
		strcat(input_file,".jpg");	// add file extension	
		
	printf("\nWriting result to Output file: %s\n", input_file);
		
	// write result to output file
	OutputFile = fopen(input_file,"wb");
	if (OutputFile==NULL)
	{
		fprintf(fperr, "Error while opening the output file: %s \n", input_file);
		return CODEC_FILE_ERROR;
	}
	// Check video mode
	if (VideoMode == ITU656_PAL)
	    printf ("\nCaptured an ITU656 PAL video frame\n");	
	else // video mode must be ITU656_NTSC
	    printf ("\nCaptured an ITU656 NTSC video frame\n");

#ifdef ADI_MMSK_EXTRA_INFO		// macro to enable extra debug information    	
	printf("\nSending encoded file to Host via USB\n");	
	START_CYCLE_COUNT(start_count)	// begin counting time
#endif

	// Store bitstream in file
	fwrite(StreamBuffer, 1, NumBytes, OutputFile);
	
#ifdef ADI_MMSK_EXTRA_INFO		// Extra debug information
	STOP_CYCLE_COUNT(final_count,start_count)	// stop counting
#endif // ADI_MMSK_EXTRA_INFO	
	
	// Free and destory used resources
	// close output file
	fclose(OutputFile);	
	
#ifdef ADI_MMSK_EXTRA_INFO		// Extra debug information	
	printf("Took %lu cycles",final_count);	
	printf(" to write %d bytes\n\n",NumBytes);	
#endif // ADI_MMSK_EXTRA_INFO	    
			
	// free the memory
	JPEG_MemAlloc_DELETE(StreamBuffer_Obj);  

	printf("***  JPEG Conversion successful ***\n");
	
  	return CODEC_SUCCESS;
}

/*****/