📄 jpeg_bitsbuffer.c
字号:
" IF !CC JUMP JBW4;\n"
" P2 = [P0 + 36];\n"
" P5 = [P0]; P4 = [P0 + 12];\n"
" P1 = [P0 + 8];\n"
" R3 = [P0 + 4];\n"
" R2 = [P0 + 16];\n"
" CC = R2 == 0;\n"
" IF CC P1 = R3;\n"
" LSETUP (JBW0, JBW1) LC0=P2;\n"
" P5 = P5 + P4;\n"
" P4 = P4 + P2;\n"
" [P0 + 12] = P4;\n"
"JBW0: R1 = B[P1++] (Z);\n"
"JBW1: B[P5++] = R1;\n"
"JBW3: R2 = R2 -|- R2 || R1 = [P0 + 28];\n"
" R3 = [P0 + 32];\n"
" R3 = R0 + R3 (NS) || [P0 + 36] = R2;\n"
" R1 = R0 + R1 (NS) || [P0 + 20] = R0;\n"
" [P0 + 32] = R3;\n"
" [P0 + 28] = R1;\n"
"JBW4: (P5:4) = [SP++]; RTS;\n."
"global _JPEG_BitsBuffer_WRITE;\n");
#else
int JPEG_BitsBuffer_WRITE (tBitsBuffer *bitsbuf, int numBytes) {
int lCount;
unsigned char *lPointer;
bitsbuf->numBytes += numBytes;
if(bitsbuf->numBytes > bitsbuf->dmaInitiateThreshold) {
if(bitsbuf->firstOrsecondBuffer == 0) lPointer = bitsbuf->desBuffer1;
else lPointer = bitsbuf->desBuffer2;
for(lCount = 0; lCount < bitsbuf->numBytes ; lCount++)
bitsbuf->externalBuffer[bitsbuf->externalBufferIndex++] = lPointer[lCount];
bitsbuf->numBytes = 0;
bitsbuf->nextBuffer = 1;
bitsbuf->writeBufferCount++;
bitsbuf->numberOfEmptyBuffers++;
}
return (E_TRUE);
}
#endif
#endif
/*
********************************************************************************
** Function: JPEG_BitsBuffer_FLUSH
**
** Description: This function flushes all the data buffers.
** Used in JPEG ENCODER only.
**
** Arguments:
** bitsbuf [IN] Handle to the Bit Stream data access instance.
**
** Outputs:
**
** Return value: The number of bytes written (zero if unsuccessful).
********************************************************************************
*/
#if USE_DMA
int JPEG_BitsBuffer_FLUSH (tBitsBuffer *bitsbuf)
{
int lCount;
if(bitsbuf->numBytes > 0)
{
if(bitsbuf->firstOrsecondBuffer == 0)
{
bitsbuf->dmaIDs[bitsbuf->firstOrsecondBuffer] = DMA_BitsBuffer(&bitsbuf->externalBuffer[bitsbuf->externalBufferIndex],
bitsbuf->desBuffer1, bitsbuf->numBytes);
bitsbuf->externalBufferIndex += bitsbuf->numBytes;
}
else
{
bitsbuf->dmaIDs[bitsbuf->firstOrsecondBuffer] = DMA_BitsBuffer(&bitsbuf->externalBuffer[bitsbuf->externalBufferIndex],
bitsbuf->desBuffer2, bitsbuf->numBytes);
bitsbuf->externalBufferIndex += bitsbuf->numBytes;
}
bitsbuf->numBytes = 0;
bitsbuf->nextBuffer = 1;
bitsbuf->numberOfEmptyBuffers++;
}
return bitsbuf->externalBufferIndex;
}
#else
#ifdef JPEGBUFFERVALIDATED
asm(".section program;\n"
".global _JPEG_BitsBuffer_FLUSH;\n"
".align 8;\n"
"_JPEG_BitsBuffer_FLUSH:\n"
" P0 = R0;\n"
" R2 = 1;\n"
" [--SP] = (P5:4);\n"
" R3 = [P0 + 36];\n"
" CC = R3 <= 0;\n"
" IF CC JUMP JBF3;\n"
" P2 = R3; P1 = [P0 + 4];\n"
" P4 = [P0 + 12];\n"
" P5 = [P0];\n"
" R0 = [P0 + 16];\n"
" CC = R0 == 0;\n"
" R0 = [P0 + 8];\n"
" IF !CC P1 = R0; \n"
" LSETUP (JBF1, JBF2) LC0=P2;\n"
" P5 = P5 + P4;\n"
" P2 = P2 + P4;\n"
" [P0 + 12] = P2;\n"
"JBF1: R1 = B[P1++] (Z);\n"
"JBF2: B[P5++] = R1;\n"
" R1 = R1 -|- R1 || R0=[P0 + 28];\n"
" R0 = R0 + R2 (NS) || [P0 + 36] = R1;\n"
" [P0 + 20] = R2;\n"
" [P0 + 28] = R0;\n"
"JBF3: R0 = [P0 + 12]; (P5:4) = [SP++]; RTS;\n");
#else
int JPEG_BitsBuffer_FLUSH (tBitsBuffer *bitsbuf)
{
int lCount;
unsigned char *lPointer;
if(bitsbuf->numBytes > 0) {
if(bitsbuf->firstOrsecondBuffer == 0) lPointer = bitsbuf->desBuffer1;
else lPointer = bitsbuf->desBuffer2;
for(lCount = 0; lCount < bitsbuf->numBytes ; lCount++)
bitsbuf->externalBuffer[bitsbuf->externalBufferIndex++] = lPointer[lCount];
bitsbuf->numBytes = 0;
bitsbuf->nextBuffer = 1;
bitsbuf->numberOfEmptyBuffers++;
}
return bitsbuf->externalBufferIndex;
}
#endif
#endif
/*
********************************************************************************
Function Name: JPEG_BitsBuffer_READ
Parameters:
handle [IN]: Handle to Bit Stream Buffer data access instance.
Return Value: int : TRUE(1) or FALSE(0).
Description: This function is used to preload a data buffer for processing.
FALSE is returned if there are no empty data buffers available for
filling. This must be called at least once before calling the
function JPEG_BitsBuffer_PROCESS.
Used in JPEG DECODER only.
********************************************************************************
*/
#ifdef DECODER_SINGLE_BUFFERED
#ifdef JPEGBUFFERVALIDATED
asm(".section program;\n"
".align 8;\n"
"_JPEG_BitsBuffer_READ:\n"
" P0 = R0; [--SP]=LC0; [--SP]=LT0; [--SP]=LB0;\n"
" R0 = R0 -|- R0 || R1 = [P0 + 28];\n"
" CC = R1 == 0;\n"
" IF CC JUMP JBR4;\n"
" R0 = [P0 + 56];\n"
" CC = R0 == 0;\n"
" R0 = 1;\n"
" IF !CC JUMP JBR4;\n"
" P1 = [P0 + 4];\n"
" R2 = [P0 + 84];\n"
" R1 = [P0 + 88];\n"
" CC = R2 <= R1;\n"
" R0 = CC;\n"
" [P0 + 56] = R0;\n"
" IF CC JUMP JBR4;\n"
" R3 = [P0 + 80];\n"
" R3 = R1 + R3;\n"
" I3 = R3;\n"
" R0 = 1024 (X);\n"
" R2 = R2 - R1;\n"
" R0 = MIN (R0,R2);\n"
" R3 = R0 + R1 (NS) || [P0 + 48] = R0;\n"
" I0.L = 0;\n"
" R0 += 3;\n"
" R2 = R0 >>> 2 || R0 = [I3++];\n"
" P2 = R2;\n"
" [P0 + 88] = R3;\n"
" R3 = [P0 + 28] || (R1,R0) = BYTEUNPACK R1:0;\n"
" R3 += -1;\n"
" [P0 + 28] = R3 || R3 = PACK(R0.L, R0.H) ;\n"
" LSETUP(JBR2,JBR3) LC0=P2;\n"
"JBR2: R2 = PACK(R1.L, R1.H) || R0=[I3++];\n"
" (R1,R0) = BYTEUNPACK R1:0;\n"
" R2 = BYTEPACK (R2,R3);\n"
"JBR3: [P1++]=R2 || R3 = PACK(R0.L, R0.H) ;\n"
" R0 = 1;\n"
"JBR4: LB0 = [SP++]; LT0 = [SP++]; LC0 = [SP++]; RTS;\n"
".global _JPEG_BitsBuffer_READ;\n");
#else
#ifdef JPEGBUFFER
void Swap4Bytes (int count,int * ptr1,int * ptr2) {
asm("P0=R0;\nP1=R1;\nP2=R2;\n[--SP]=LC0;\n[--SP]=LT0;\n[--SP]=LB0;\nI0.L=0;\n"
"R0=[P1++];\n"
"(r1,r0) = byteunpack r1:0;\n"
"LSETUP(SWBS,SWBE) LC0=P0;\n"
"SWBS: r3=pack(r0.l, r0.h) || R0=[P1++];\n"
"r2=pack(r1.l, r1.h) ;\n"
"R2 = bytepack (R2,R3) ;\n"
"SWBE: [P2++]=R2 || (r1,r0) = byteunpack r1:0;\n"
"LB0=[SP++];\nLT0=[SP++];\nLC0=[SP++];\n" );
return;
}
#endif
int JPEG_BitsBuffer_READ(tBitsBuffer *bitsbuf)
{
uint8 *pbuffer;
int *pBytesRead;
int lCnt;
unsigned int *lBuffWord,*pInput;
if(bitsbuf->numberOfEmptyBuffers==0) return E_FALSE;
if(bitsbuf->end_of_file) return E_TRUE;
pbuffer = bitsbuf->desBuffer1;
pBytesRead = &bitsbuf->numBytesBuf_1;
if(bitsbuf->InputFilePosition >= bitsbuf->BitStreamFileSize) {
bitsbuf->end_of_file = 1; return E_TRUE; }
lCnt = bitsbuf->BitStreamFileSize - bitsbuf->InputFilePosition;
*pBytesRead = (lCnt<BITS_BUF_DESBUF_SIZE) ? lCnt : BITS_BUF_DESBUF_SIZE;
lBuffWord = (unsigned int *)pbuffer;
pInput = (unsigned int *)(bitsbuf->InputBitstreamFile + bitsbuf->InputFilePosition);
bitsbuf->InputFilePosition += *pBytesRead;
#ifdef JPEGBUFFER
Swap4Bytes(((*pBytesRead+3)>>2),(int *) pInput,(int *) lBuffWord);
#else
for(lCnt=0; lCnt<((*pBytesRead+3) >>2); lCnt++)
lBuffWord[lCnt] = SWAP_BYTE(pInput[lCnt]);
#endif
bitsbuf->numberOfEmptyBuffers--;
return E_TRUE; // success
}
#endif
#else
#ifdef JPEGBUFFER
void Swap4Bytes (int count,int * ptr1,int * ptr2) {
asm("P0=R0;\nP1=R1;\nP2=R2;\n[--SP]=LC0;\n[--SP]=LT0;\n[--SP]=LB0;\nI0.L=0;\n"
"R0=[P1++];\n"
"(r1,r0) = byteunpack r1:0;\n"
"LSETUP(SWBS,SWBE) LC0=P0;\n"
"SWBS: r3=pack(r0.l, r0.h) || R0=[P1++];\n"
"r2=pack(r1.l, r1.h) ;\n"
"R2 = bytepack (R2,R3) ;\n"
"SWBE: [P2++]=R2 || (r1,r0) = byteunpack r1:0;\n"
"LB0=[SP++];\nLT0=[SP++];\nLC0=[SP++];\n" );
return;
}
#endif
int JPEG_BitsBuffer_READ(tBitsBuffer *bitsbuf)
{
uint8 *pbuffer;
int *pBytesRead;
int lCnt;
unsigned int *lBuffWord,*pInput;
if(bitsbuf->numberOfEmptyBuffers==0) return E_FALSE;
if(bitsbuf->end_of_file) return E_TRUE;
/* Select the buffer to be filled: */
if(bitsbuf->firstOrsecondBuffer == 0) {
pbuffer = bitsbuf->desBuffer1;
pBytesRead = &bitsbuf->numBytesBuf_1;
bitsbuf->firstOrsecondBuffer = 1;
} else {
pbuffer = bitsbuf->desBuffer2;
pBytesRead = &bitsbuf->numBytesBuf_2;
bitsbuf->firstOrsecondBuffer = 0;
}
/* check if "end of file" has been reached*/
if(bitsbuf->InputFilePosition >= bitsbuf->BitStreamFileSize) {
bitsbuf->end_of_file = 1; return E_TRUE; }
/* Fill the buffer with a single block of data from the input file: */
lCnt = bitsbuf->BitStreamFileSize - bitsbuf->InputFilePosition;
*pBytesRead = (lCnt<BITS_BUF_DESBUF_SIZE) ? lCnt : BITS_BUF_DESBUF_SIZE;
/* Reverse byte order for little-endian Blackfin processors */
/* Copied from original Pre-Alpha function */
lBuffWord = (unsigned int *)pbuffer;
pInput = (unsigned int *)(bitsbuf->InputBitstreamFile + bitsbuf->InputFilePosition);
bitsbuf->InputFilePosition += *pBytesRead;
#ifdef JPEGBUFFER
Swap4Bytes(((*pBytesRead+3)>>2),(int *) pInput,(int *) lBuffWord);
#else
for(lCnt=0; lCnt<((*pBytesRead+3) >>2); lCnt++) /* the +3 is to make sure we round up when divide by 4 */
lBuffWord[lCnt] = SWAP_BYTE(pInput[lCnt]);
#endif
bitsbuf->numberOfEmptyBuffers--;
return E_TRUE; // success
}
#endif
/*
********************************************************************************
Function Name: JPEG_BitsBuffer_PROCESS
Parameters:
handle [IN]: Handle to Bit Stream Buffer data access instance.
Return Value: char * : Pointer to the data buffer containing data ready for
processing.
*pNumBytes: Number of bytes available in buffer.
Description:This function is used to indicate to the system that the next
available Bit Stream buffer is about to be processed.
The Bit Stream data buffer must previously have been filled by a
call to the function JPEG_BitsBuffer_READ. When processing is
finished, the user must call JPEG_BitsBuffer_RELEASE to release the
data buffer. NULL is returned if there is no valid data buffer
available for processing.
Used in JPEG DECODER only.
********************************************************************************
*/
#ifdef DECODER_SINGLE_BUFFERED
#ifdef JPEGBUFFERVALIDATED
asm(".section program;\n"
".align 8;\n"
"_JPEG_BitsBuffer_PROCESS:\n"
" P0 = R0;\n"
" P1 = R1;\n"
" R0 = R0 -|- R0 || R1 = [P0 + 24];\n"
" R2 = [P0 + 28];\n"
" CC = R1 == R2;\n"
" IF CC JUMP JBP1;\n"
" R1 = [P0 + 56];\n"
" CC = R1 == 0;\n"
" IF !CC JUMP JBP1;\n"
" R1 = [P0 + 48];\n"
" R0 = [P0 + 4];\n"
" [P1] = R1;\n"
"JBP1: RTS;\n"
".global _JPEG_BitsBuffer_PROCESS;\n");
#else
unsigned char *JPEG_BitsBuffer_PROCESS(tBitsBuffer *bitsbuf, int *pNumBytes){
uint8 *pbuffer;
if(bitsbuf->numberOfEmptyBuffers==bitsbuf->numberOfBuffers) return NULL;
if(bitsbuf->end_of_file) return NULL;
pbuffer = bitsbuf->desBuffer1;
*pNumBytes = bitsbuf->numBytesBuf_1;
return pbuffer;
}
#endif
#else
unsigned char *JPEG_BitsBuffer_PROCESS(tBitsBuffer *bitsbuf, int *pNumBytes)
{
uint8 *pbuffer;
if(bitsbuf->numberOfEmptyBuffers==bitsbuf->numberOfBuffers) return NULL;
if(bitsbuf->end_of_file) return NULL;
/* Process opposite buffer to buffer previously filled */
if(bitsbuf->firstOrsecondBuffer == 0) {
pbuffer = bitsbuf->desBuffer1;
*pNumBytes = bitsbuf->numBytesBuf_1;
} else {
pbuffer = bitsbuf->desBuffer2;
*pNumBytes = bitsbuf->numBytesBuf_2;
}
return pbuffer;
}
#endif
/*
********************************************************************************
Function Name: JPEG_BitsBuffer_RELEASE
Parameters: handle [IN]: Handle to Bit Stream Buffer data access instance.
Return Value: none.
Description: This function is used to release a data buffer that is currently
being processed. This must be called after calling the function
JPEG_BitsBuffer_PROCESS.
Used in JPEG DECODER only.
********************************************************************************
*/
#ifndef DECODER_SINGLE_BUFFERED
void JPEG_BitsBuffer_RELEASE(tBitsBuffer *bitsbuf)
{
/* Release buffer that was last processed: */
if(bitsbuf->end_of_file)
{
return;
}
if(bitsbuf->firstOrsecondBuffer == 0)
{
bitsbuf->numBytesBuf_1 = 0;
bitsbuf->firstOrsecondBuffer = 1;
}
else
{
bitsbuf->numBytesBuf_2 = 0;
bitsbuf->firstOrsecondBuffer = 0;
}
bitsbuf->numberOfEmptyBuffers++;
}
#else
#ifdef JPEGBUFFERVALIDATED
asm(".section program;\n"
".align 8;\n"
".global _JPEG_BitsBuffer_RELEASE;\n"
"_JPEG_BitsBuffer_RELEASE:\n"
" P0 = R0;\n"
" R1 = 1; NOP; NOP; NOP;\n"
" R0 = [P0 + 56];\n"
" CC = R0 == 0;\n"
" R0 = [P0 + 28];\n"
" R1 = R1 + R0;\n"
" IF CC R0 = R1;\n"
" [P0 + 28] = R0;\n"
" RTS;\n");
#else
void JPEG_BitsBuffer_RELEASE(tBitsBuffer *bitsbuf) {
if(bitsbuf->end_of_file) return; bitsbuf->numberOfEmptyBuffers++; }
#endif
#endif
/*
********************************************************************************
** Function: JPEG_TempBuffer_CAT
**
** Description: Concatenates a Temporary buffer and a Bits Buffer.
** For general use.
**
** Arguments:
** src [IN] Pointer to Temporary Bit Stream data access instance.
** dest [OUT] Pointer to Bit Stream data access instance.
** NOTE: The destination Bit Stream memory must be
** large enough to hold the concatenated data.
**
** Outputs:
**
** Return value: None
********************************************************************************
*/
void JPEG_TempBuffer_CAT(tBitsBuffer *dest_buf, const tBitsBuffer *src_buf)
{
unsigned char *src_pointer = src_buf->externalBuffer;
unsigned char *dest_pointer = dest_buf->externalBuffer
+ dest_buf->externalBufferIndex;
int i;
#if USE_DMA
ulong dmaID; // dma identifier
/* Copy source to end of destination buffer */
dmaID = DMA_BitsBuffer(dest_pointer,
src_pointer, src_buf->externalBufferIndex);
// no processing done in the background, make sure DMA is completed now.
dma_done(dmaID);
dest_buf->externalBufferIndex += src_buf->externalBufferIndex;
#else
/* Copy source to end of destination buffer */
for(i=0; i<src_buf->externalBufferIndex; i++)
{
dest_pointer[i] = src_pointer[i];
dest_buf->externalBufferIndex++;
}
#endif // USE_DMA
}
tBitsBuffer *JPEG_TempBuffer_NEW(void)
{
return (tBitsBuffer *)JPEG_BitsBuffer_NEW();
}
int JPEG_TempBuffer_CONFIG(tBitsBuffer *handle, eBitsBuf_config item, int value)
{
return JPEG_BitsBuffer_CONFIG((tBitsBuffer *)handle, item, value);
}
int JPEG_TempBuffer_INIT(tBitsBuffer *handle)
{
return JPEG_BitsBuffer_INIT((tBitsBuffer *)handle);
}
void JPEG_TempBuffer_DELETE(tBitsBuffer *handle)
{
JPEG_BitsBuffer_DELETE((tBitsBuffer *)handle);
}
int JPEG_TempBuffer_RESET(tBitsBuffer *handle)
{
return JPEG_BitsBuffer_RESET((tBitsBuffer *)handle);
}
unsigned char *JPEG_TempBuffer_REQUEST(tBitsBuffer *handle)
{
return JPEG_BitsBuffer_REQUEST((tBitsBuffer *)handle);
}
int JPEG_TempBuffer_WRITE(tBitsBuffer *handle, int numBytes)
{
return JPEG_BitsBuffer_WRITE((tBitsBuffer *)handle, numBytes);
}
int JPEG_TempBuffer_FLUSH(tBitsBuffer *handle)
{
return JPEG_BitsBuffer_FLUSH((tBitsBuffer *)handle);
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -