Hi All ,
I have written an application over dm355 that saves raw image and Yuv image
files .Furthur it converts it to jpg format using Jpegenc .
I found that jpg image i got is just 2 black /blue belts ,having size 73 KB's .
Raw image and YUV image size is like 1.5 MB each and resolution is 1024*768.
could any one help me to get exact image to view ?
Ashish
My App code is :-
/*
* Copyright 2008 by Texas Instruments Incorporated.
* All rights reserved. Property of Texas Instruments Incorporated.
* Restricted rights to use, duplicate or disclose this code are
* granted through contract.
*
* @(#) imports/build 1_00_00_43 040908 (linuxdemos-a44x)
*/
/*
* ======== jpegenc.c ========
*
* A simple example of encoding an image using the JPEG encoder.
*/
//typedef int bool;
#include <xdc/std.h>
#include <ti/sdo/ce/Engine.h>
#include <ti/sdo/ce/osal/Memory.h>
#include <ti/sdo/ce/image1/imgenc1.h>
#include <ti/sdo/ce/trace/gt.h>
#include <ti/sdo/codecs/jpegenc/dm355/ijpegenc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <asm/types.h>
#include <linux/videodev.h>
#include <media/davinci/davinci_vpfe.h>
#include <media/davinci/ccdc_dm355.h>
#include <asm/arch/dm355_ipipe.h>
#include "ipipe_example.h"
#include "ipipe_config.h"
#include "mt9t001_capture.h"
/*
* The parameters for the encoding process. These can be changed to try
* different image sizes and JPEG features.
*/
#define SCANS 4
#define QVALUE 73
/* this example only supports YUV422 interleaved */
#define CHROMAFORMAT XDM_YUV_422ILE
//#define CHROMAFORMAT XDM_YUV_422P
/* Not a cached system, no buffer alignment constraints */
#define BUFALIGN Memory_DEFAULTALIGNMENT
static XDAS_Int8 *inBuf;
static XDAS_Int8 *encodedBuf;
static XDAS_Int32 inBufSize;
static XDAS_Int32 encodedBufSize;
static String progName = "app";
static String encoderName = "jpegenc";
static String engineName = "image";
static String image_base_name = "image";
extern GT_Mask curMask;
static Int32 encode(IMGENC1_Handle enc, XDAS_Int8 * in, XDAS_Int8 * out );
void save( void * data, int len, char * basename, char * ext );
/*
* ======== smain ========
*/
Int smain(Int argc, String argv[])
{
Engine_Handle ce = NULL;
IMGENC1_Handle enc = NULL;
IMGENC1_Params encParams;
IMGENC1_DynamicParams dynParams;
IMGENC1_Status imgStatus;
IJPEGENC_DynamicParams extDynParams;
char outFile[80];
int capbuf_phyaddr;
struct buffer * capbuf;
struct buffer ipipebuffer;
int length;
// Setup the capture device
InitCaptureDevice(CAP_FORMAT, CAP_WIDTH, CAP_HEIGHT);
// Initialize the IPIPE to just convert from bayer to YCC
InitIpipe( RAW2YUV
,CAP_WIDTH
,CAP_HEIGHT
,CAP_WIDTH
,CAP_HEIGHT
,&ipipebuffer
);
// Create a name for the output file
sprintf( outFile, "%s_%04d", image_base_name, 0 );
GT_0trace(curMask, GT_1CLASS, "Application started.\n");
/* open the Codec Engine */
if ((ce = Engine_open(engineName, NULL, NULL)) == NULL) {
fprintf(stderr, "ERROR: can't open engine %s\n", engineName);
goto end;
}
printf("Engine Successfully Opend :\n");
/* allocate and initialize image encoder on the engine */
encParams.size = sizeof(IMGENC1_Params);
encParams.maxWidth = CAP_WIDTH;
encParams.maxHeight = CAP_HEIGHT;
encParams.maxScans = SCANS;
encParams.dataEndianness = XDM_DEFAULT;
encParams.forceChromaFormat = CHROMAFORMAT;
enc = IMGENC1_create(ce, encoderName, &encParams);
if (enc == NULL) {
fprintf(stderr, "%s: error: can't open codec %s\n",
progName, encoderName);
goto end;
}
printf("Codec Successfully Opend :\n");
/* set the parameters for encoding */
dynParams.size = sizeof(IMGENC1_DynamicParams);
dynParams.numAU = XDM_DEFAULT;
dynParams.inputChromaFormat = CHROMAFORMAT;
dynParams.inputHeight = CAP_HEIGHT;
dynParams.inputWidth = CAP_WIDTH;
dynParams.captureWidth = 0;
dynParams.generateHeader = XDM_ENCODE_AU;
dynParams.qValue = QVALUE;
#if 0
/* set the extended parameters for encoding */
extDynParams.imgencDynamicParams = dynParams;
extDynParams.rstInterval = XDM_DEFAULT;
extDynParams.disableEOI = XDM_DEFAULT;
extDynParams.rotation = 90;
extDynParams.customQ = NULL;
imgStatus.size = sizeof(imgStatus);
if (IMGENC1_control(enc, XDM_SETPARAMS, (IMGENC1_DynamicParams
*)&extDynParams, &imgStatus) ==
XDM_EFAIL) {
fprintf(stderr, "%s: error: could not set PARAMS: 0x%x\n", progName,
(unsigned int)imgStatus.extendedError);
goto end;
}
#else
imgStatus.size = sizeof(imgStatus);
if (IMGENC1_control(enc, XDM_SETPARAMS, &dynParams, &imgStatus) ==
XDM_EFAIL) {
fprintf(stderr, "%s: error: could not set PARAMS: 0x%x\n", progName,
(unsigned int)imgStatus.extendedError);
goto end;
}
printf("Engine PARAMS Successfully Set :\n");
#endif
/* ask the codec for buffer sizes - these are typically conservative */
if (IMGENC1_control(enc, XDM_GETBUFINFO, &dynParams, &imgStatus) ==
XDM_EFAIL) {
fprintf(stderr, "%s: error: could not get BUFINFO: 0x%x\n", progName,
(unsigned int)imgStatus.extendedError);
goto end;
}
printf("BUFINFO steps done :\n");
/* allocate input, encoded buffers based on GETBUFINFO */
inBufSize = imgStatus.bufInfo.minInBufSize[0];
printf("Req inbuf size,%x \n",inBufSize);
inBuf = (XDAS_Int8 *)Memory_contigAlloc(inBufSize, BUFALIGN);
if (inBuf==NULL)
printf("Memory_ContigAlloc for inbuf Not done :\n");
encodedBufSize = imgStatus.bufInfo.minOutBufSize[0];
printf("Req encodebuf size,%x \n",encodedBufSize);
encodedBuf = (XDAS_Int8 *)Memory_contigAlloc(encodedBufSize, BUFALIGN);
if(encodedBuf == NULL)
printf("Memory_ContigAlloc for encodeBuf Not done :\n");
if ((inBuf == NULL) || (encodedBuf == NULL)) {
printf("Memory_ContigAlloc Not done :\n");
goto end;
}
// Start the video stream
StartStreaming();
// Capture a frame
capbuf = CaptureFrame(&capbuf_phyaddr);
// Stop the video stream
StopStreaming();
printf("Streaming Stop\n");
sleep(1);
// Convert the frame from bayer to YCC
DoIPIPING( RAW2YUV
,CAP_WIDTH
,CAP_HEIGHT
,CAP_WIDTH
,CAP_HEIGHT
,capbuf_phyaddr
);
printf("Ipiping Done \n");
/* Copy the data to where the encoder can access it */
printf("Copying data for encoder access\n");
memcpy( inBuf, ipipebuffer.start, inBufSize );
printf("Data copied for encoder\n");
/* use engine to encode the data */
length = encode(enc, inBuf, encodedBuf );
printf("Images Saving....\n");
save( capbuf->start, CAP_HEIGHT * CAP_WIDTH * sizeof( unsigned short ),
outFile, "raw" );
save( ipipebuffer.start, CAP_HEIGHT * CAP_WIDTH * sizeof( unsigned
short ), outFile, "ycc" );
save( encodedBuf, length, outFile, "jpg" );
printf("Images Saved \n");
end:
/* free buffers */
if (encodedBuf) {
Memory_contigFree(encodedBuf, encodedBufSize);
}
if (inBuf) {
Memory_contigFree(inBuf, inBufSize);
}
/* teardown the codec */
if (enc) {
IMGENC1_delete(enc);
}
/* close the engine */
if (ce) {
Engine_close(ce);
}
CloseCaptureDevice();
CloseIpipe(&ipipebuffer);
return (0);
}
/*
* ======== encode ========
*/
static Int32 encode(IMGENC1_Handle enc, XDAS_Int8 * in, XDAS_Int8 * out )
{
Int32 status;
IMGENC1_InArgs encInArgs;
IMGENC1_OutArgs encOutArgs;
IMGENC1_DynamicParams encDynParams;
XDM1_BufDesc inBufDesc;
XDM1_BufDesc encodedBufDesc;
/* initialize buffer descriptors that hold input and output buffers */
inBufDesc.numBufs = 1;
inBufDesc.descs[0].bufSize = inBufSize;
inBufDesc.descs[0].buf = in;
encodedBufDesc.numBufs = 1;
encodedBufDesc.descs[0].bufSize = encodedBufSize;
encodedBufDesc.descs[0].buf = out;
/* the size field of Args and Params structs must be initialized */
encInArgs.size = sizeof(encInArgs);
encOutArgs.size = sizeof(encOutArgs);
encDynParams.size = sizeof(encDynParams);
/* perform the image (JPEG) encoding */
printf("jpeg encoding starts\n");
status = IMGENC1_process( enc
,&inBufDesc
,&encodedBufDesc
,&encInArgs
,&encOutArgs
);
printf("jpeg encoding Done\n");
if (status == IMGENC1_EOK) {
GT_2trace(curMask, GT_2CLASS,
"Encoder process returned - 0x%x, %d bytes\n", status,
encOutArgs.bytesGenerated
);
}
else {
GT_2trace(curMask, GT_7CLASS,
"Encoder frame processing FAILED, status = 0x%x, "
"extendedError = 0x%x\n", status,
encOutArgs.extendedError);
}
return encOutArgs.bytesGenerated;
}
void save( void * data, int len, char * basename, char * ext )
{
char name[80];
FILE * out;
int ret;
sprintf( name, "%s.%s", basename, ext );
if ((out = fopen(name, "wb")) == NULL) {
fprintf(stderr, "ERROR: can't write to file %s\n", name);
} else {
ret = fwrite(data, 1, len, out);
if ( ret != len ) {
fprintf( stderr
,"ERROR: '%s' only wrote %d bytes,
expected %d bytes\n"
,name
,ret
,len
);
} else {
fclose( out );
}
}
}
_______________________________________________
Davinci-linux-open-source mailing list
[email protected]
http://linux.davincidsp.com/mailman/listinfo/davinci-linux-open-source
