&ptFrame, &bgFrame, &mixFrame);
// Overwrite the decoded buffer
- M4OSA_memcpy((M4OSA_MemAddr8)ptr,
- (M4OSA_MemAddr8)mixFrame.m_dataAddress, len);
+ memcpy((void *)ptr,
+ (void *)mixFrame.m_dataAddress, len);
}
}
} else if (mAudioMixSettings->bLoop){
pMixedOutBuffer->m_bufferSize = pPrimaryTrack->m_bufferSize;\r
\r
// Before mixing, we need to have only PT as out buffer\r
- M4OSA_memcpy((M4OSA_MemAddr8)pMixedOutBuffer->m_dataAddress,\r
- (M4OSA_MemAddr8)pPrimaryTrack->m_dataAddress, pMixedOutBuffer->m_bufferSize);\r
+ memcpy((void *)pMixedOutBuffer->m_dataAddress,\r
+ (void *)pPrimaryTrack->m_dataAddress, pMixedOutBuffer->m_bufferSize);\r
\r
// Initially contains the input primary track\r
pPTMdata2 = (M4OSA_Int16*)pMixedOutBuffer->m_dataAddress;\r
pPTMdata2++;\r
}\r
//LOGV("VideoEditorBGAudioProcessing:: Copy final out ");\r
- M4OSA_memcpy((M4OSA_MemAddr8)pMixedOutBuffer->m_dataAddress,\r
- (M4OSA_MemAddr8)pBackgroundTrack->m_dataAddress,\r
+ memcpy((void *)pMixedOutBuffer->m_dataAddress,\r
+ (void *)pBackgroundTrack->m_dataAddress,\r
pBackgroundTrack->m_bufferSize);\r
\r
LOGV("VideoEditorBGAudioProcessing::lvProcessAudioMixNDuck EXIT");\r
LOGE("loadEditSettings: Malloc error");\r
return M4ERR_ALLOC;\r
}\r
- M4OSA_memset((M4OSA_MemAddr8)mClipList,\r
- sizeof(M4VSS3GPP_ClipSettings*)*pSettings->uiClipNumber, 0);\r
+ memset((void *)mClipList,0,\r
+ sizeof(M4VSS3GPP_ClipSettings*)*pSettings->uiClipNumber);\r
\r
for(i=0;i<pSettings->uiClipNumber;i++) {\r
\r
return M4ERR_ALLOC;\r
}\r
// Copy plain structure\r
- M4OSA_memcpy((M4OSA_MemAddr8)mClipList[i],\r
- (M4OSA_MemAddr8)pSettings->pClipList[i],\r
+ memcpy((void *)mClipList[i],\r
+ (void *)pSettings->pClipList[i],\r
sizeof(M4VSS3GPP_ClipSettings));\r
\r
if(NULL != pSettings->pClipList[i]->pFile) {\r
return M4ERR_ALLOC;\r
}\r
\r
- M4OSA_memcpy((M4OSA_MemAddr8)mClipList[i]->pFile,\r
- (M4OSA_MemAddr8)pSettings->pClipList[i]->pFile,\r
+ memcpy((void *)mClipList[i]->pFile,\r
+ (void *)pSettings->pClipList[i]->pFile,\r
pSettings->pClipList[i]->filePathSize);\r
}\r
else {\r
return M4ERR_ALLOC;\r
}\r
\r
- M4OSA_memset((M4OSA_MemAddr8)mEffectsSettings,\r
- mNumberEffects*sizeof(M4VSS3GPP_EffectSettings), 0);\r
+ memset((void *)mEffectsSettings,0,\r
+ mNumberEffects*sizeof(M4VSS3GPP_EffectSettings));\r
\r
for(i=0;i<mNumberEffects;i++) {\r
\r
mEffectsSettings[i].xVSS.pFramingBuffer = NULL;\r
mEffectsSettings[i].xVSS.pTextBuffer = NULL;\r
\r
- M4OSA_memcpy((M4OSA_MemAddr8)&(mEffectsSettings[i]),\r
- (M4OSA_MemAddr8)&(pSettings->Effects[i]),\r
+ memcpy((void *)&(mEffectsSettings[i]),\r
+ (void *)&(pSettings->Effects[i]),\r
sizeof(M4VSS3GPP_EffectSettings));\r
\r
if(pSettings->Effects[i].VideoEffectType ==\r
pSettings->Effects[i].xVSS.uialphaBlendingFadeOutTime;\r
\r
// Copy the pFraming data\r
- M4OSA_memcpy((M4OSA_MemAddr8)\r
+ memcpy((void *)\r
mEffectsSettings[i].xVSS.pFramingBuffer->pac_data,\r
- (M4OSA_MemAddr8)pSettings->Effects[i].xVSS.pFramingBuffer->pac_data,\r
+ (void *)pSettings->Effects[i].xVSS.pFramingBuffer->pac_data,\r
rgbSize);\r
\r
mEffectsSettings[i].xVSS.rgbType =\r
return M4ERR_ALLOC;\r
}\r
\r
- M4OSA_memset((M4OSA_MemAddr8)mBackgroundAudioSetting, sizeof(M4xVSS_AudioMixingSettings*), 0);\r
- M4OSA_memcpy((M4OSA_MemAddr8)mBackgroundAudioSetting, (M4OSA_MemAddr8)bgmSettings, sizeof(M4xVSS_AudioMixingSettings));\r
+ memset((void *)mBackgroundAudioSetting, 0,sizeof(M4xVSS_AudioMixingSettings*));\r
+ memcpy((void *)mBackgroundAudioSetting, (void *)bgmSettings, sizeof(M4xVSS_AudioMixingSettings));\r
\r
if ( mBackgroundAudioSetting->pFile != M4OSA_NULL ) {\r
\r
(M4OSA_UInt32)outBufferStride, (M4VIFI_UInt8 *)outBuffer);\r
\r
/* Fill the surface with black frame */\r
- M4OSA_memset((M4OSA_MemAddr8)planeOut[0].pac_data,planeOut[0].u_width *\r
- planeOut[0].u_height * 1.5,0x00);\r
- M4OSA_memset((M4OSA_MemAddr8)planeOut[1].pac_data,planeOut[1].u_width *\r
- planeOut[1].u_height,128);\r
- M4OSA_memset((M4OSA_MemAddr8)planeOut[2].pac_data,planeOut[2].u_width *\r
- planeOut[2].u_height,128);\r
+ memset((void *)planeOut[0].pac_data,0x00,planeOut[0].u_width *\r
+ planeOut[0].u_height * 1.5);\r
+ memset((void *)planeOut[1].pac_data,128,planeOut[1].u_width *\r
+ planeOut[1].u_height);\r
+ memset((void *)planeOut[2].pac_data,128,planeOut[2].u_width *\r
+ planeOut[2].u_height);\r
\r
mTarget->renderYV12();\r
return err;\r
/* The input Y Plane is the same as the output Y Plane */\r
p_buf_src = &(PlaneIn[0].pac_data[PlaneIn[0].u_topleft]);\r
p_buf_dest = &(PlaneOut[0].pac_data[PlaneOut[0].u_topleft]);\r
- M4OSA_memcpy((M4OSA_Int8*)p_buf_dest,(M4OSA_Int8*)p_buf_src ,\r
+ memcpy((void *)p_buf_dest,(void *)p_buf_src ,\r
PlaneOut[0].u_width * PlaneOut[0].u_height);\r
\r
/* The U and V components are planar. The need to be made interleaved */\r
/* The input Y Plane is the same as the output Y Plane */\r
p_buf_src = &(PlaneIn[0].pac_data[PlaneIn[0].u_topleft]);\r
p_buf_dest = &(PlaneOut[0].pac_data[PlaneOut[0].u_topleft]);\r
- M4OSA_memcpy((M4OSA_Int8*)p_buf_dest,(M4OSA_Int8*)p_buf_src ,\r
+ memcpy((void *)p_buf_dest,(void *)p_buf_src ,\r
PlaneOut[0].u_width * PlaneOut[0].u_height);\r
\r
/* The U and V components are planar. The need to be made interleaved */\r
switch (ColorContext->colorEffectType)\r
{\r
case M4xVSS_kVideoEffectType_BlackAndWhite:\r
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,\r
- PlaneIn[plane_number].u_width, 128);\r
+ memset((void *)p_buf_dest,128,\r
+ PlaneIn[plane_number].u_width);\r
break;\r
case M4xVSS_kVideoEffectType_Pink:\r
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,\r
- PlaneIn[plane_number].u_width, 255);\r
+ memset((void *)p_buf_dest,255,\r
+ PlaneIn[plane_number].u_width);\r
break;\r
case M4xVSS_kVideoEffectType_Green:\r
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,\r
- PlaneIn[plane_number].u_width, 0);\r
+ memset((void *)p_buf_dest,0,\r
+ PlaneIn[plane_number].u_width);\r
break;\r
case M4xVSS_kVideoEffectType_Sepia:\r
if(plane_number==1)\r
{\r
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,\r
- PlaneIn[plane_number].u_width, 117);\r
+ memset((void *)p_buf_dest,117,\r
+ PlaneIn[plane_number].u_width);\r
}\r
else\r
{\r
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,\r
- PlaneIn[plane_number].u_width, 139);\r
+ memset((void *)p_buf_dest,139,\r
+ PlaneIn[plane_number].u_width);\r
}\r
break;\r
case M4xVSS_kVideoEffectType_Negative:\r
- M4OSA_memcpy((M4OSA_MemAddr8)p_buf_dest,\r
- (M4OSA_MemAddr8)p_buf_src ,PlaneOut[plane_number].u_width);\r
+ memcpy((void *)p_buf_dest,\r
+ (void *)p_buf_src ,PlaneOut[plane_number].u_width);\r
break;\r
\r
case M4xVSS_kVideoEffectType_ColorRGB16:\r
{\r
/*then convert to u*/\r
u = U16(r, g, b);\r
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,\r
- PlaneIn[plane_number].u_width, (M4OSA_UInt8)u);\r
+ memset((void *)p_buf_dest,(M4OSA_UInt8)u,\r
+ PlaneIn[plane_number].u_width);\r
}\r
if(plane_number==2)\r
{\r
/*then convert to v*/\r
v = V16(r, g, b);\r
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,\r
- PlaneIn[plane_number].u_width, (M4OSA_UInt8)v);\r
+ memset((void *)p_buf_dest,(M4OSA_UInt8)v,\r
+ PlaneIn[plane_number].u_width);\r
}\r
}\r
break;\r
{\r
/*then convert to u*/\r
u = U16(r, g, b);\r
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,\r
- PlaneIn[plane_number].u_width, (M4OSA_UInt8)u);\r
+ memset((void *)p_buf_dest,(M4OSA_UInt8)u,\r
+ PlaneIn[plane_number].u_width);\r
}\r
if(plane_number==2)\r
{\r
/*then convert to v*/\r
v = V16(r, g, b);\r
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,\r
- PlaneIn[plane_number].u_width, (M4OSA_UInt8)v);\r
+ memset((void *)p_buf_dest,(M4OSA_UInt8)v,\r
+ PlaneIn[plane_number].u_width);\r
}\r
}\r
break;\r
}\r
break;\r
default:\r
- M4OSA_memcpy((M4OSA_MemAddr8)p_buf_dest,\r
- (M4OSA_MemAddr8)p_buf_src ,PlaneOut[plane_number].u_width);\r
+ memcpy((void *)p_buf_dest,\r
+ (void *)p_buf_src ,PlaneOut[plane_number].u_width);\r
break;\r
}\r
}\r
for (x = 0; x < pPlaneOut[plane_number].u_height; x++)\r
{\r
if (1 == plane_number)\r
- M4OSA_memset((M4OSA_MemAddr8)pOutCr, pPlaneIn[plane_number].u_width, 117); /* U value */\r
+ memset((void *)pOutCr, 117,pPlaneIn[plane_number].u_width); /* U value */\r
else\r
- M4OSA_memset((M4OSA_MemAddr8)pOutCr, pPlaneIn[plane_number].u_width, 139); /* V value */\r
+ memset((void *)pOutCr, 139,pPlaneIn[plane_number].u_width); /* V value */\r
\r
pInCr += pPlaneIn[plane_number].u_stride;\r
pOutCr += pPlaneOut[plane_number].u_stride;\r
{\r
for (i = u_width; i != 0; i--)\r
{\r
- M4OSA_memcpy((M4OSA_MemAddr8)p_cdest_line, (M4OSA_MemAddr8)p_csrc_line, u_width);\r
- M4OSA_memcpy((M4OSA_MemAddr8)p_cdest, (M4OSA_MemAddr8)p_csrc, u_width);\r
+ memcpy((void *)p_cdest_line, (void *)p_csrc_line, u_width);\r
+ memcpy((void *)p_cdest, (void *)p_csrc, u_width);\r
}\r
p_cdest_line += u_stride_out;\r
p_cdest += u_stride_out;\r
/* write black lines */\r
for (j = (nb_black_lines >> 1); j != 0; j--)\r
{\r
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 0);\r
+ memset((void *)p_dest, 0,u_width);\r
p_dest += u_stride_out;\r
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 0);\r
+ memset((void *)p_dest, 0,u_width);\r
p_dest += u_stride_out;\r
- M4OSA_memset((M4OSA_MemAddr8)p_destu, u_widthuv, 128);\r
- M4OSA_memset((M4OSA_MemAddr8)p_destv, u_widthuv, 128);\r
+ memset((void *)p_destu, 128,u_widthuv);\r
+ memset((void *)p_destv, 128,u_widthuv);\r
p_destu += u_stride_out_uv;\r
p_destv += u_stride_out_uv;\r
}\r
/* copy from source image */\r
for (j = (u_height - nb_black_lines) >> 1; j != 0; j--)\r
{\r
- M4OSA_memcpy((M4OSA_MemAddr8)p_dest, (M4OSA_MemAddr8)p_src, u_width);\r
+ memcpy((void *)p_dest, (void *)p_src, u_width);\r
p_dest += u_stride_out;\r
p_src += u_stride;\r
- M4OSA_memcpy((M4OSA_MemAddr8)p_dest, (M4OSA_MemAddr8)p_src, u_width);\r
+ memcpy((void *)p_dest, (void *)p_src, u_width);\r
p_dest += u_stride_out;\r
p_src += u_stride;\r
- M4OSA_memcpy((M4OSA_MemAddr8)p_destu, (M4OSA_MemAddr8)p_srcu, u_widthuv);\r
- M4OSA_memcpy((M4OSA_MemAddr8)p_destv, (M4OSA_MemAddr8)p_srcv, u_widthuv);\r
+ memcpy((void *)p_destu, (void *)p_srcu, u_widthuv);\r
+ memcpy((void *)p_destv, (void *)p_srcv, u_widthuv);\r
p_destu += u_stride_out_uv;\r
p_destv += u_stride_out_uv;\r
p_srcu += u_stride_uv;\r
/* copy from source image image */\r
for (j = (nb_black_lines >> 1); j != 0; j--)\r
{\r
- M4OSA_memcpy((M4OSA_MemAddr8)p_dest, (M4OSA_MemAddr8)p_src, u_width);\r
+ memcpy((void *)p_dest, (void *)p_src, u_width);\r
p_dest += u_stride_out;\r
p_src += u_stride;\r
- M4OSA_memcpy((M4OSA_MemAddr8)p_dest, (M4OSA_MemAddr8)p_src, u_width);\r
+ memcpy((void *)p_dest, (void *)p_src, u_width);\r
p_dest += u_stride_out;\r
p_src += u_stride;\r
- M4OSA_memcpy((M4OSA_MemAddr8)p_destu, (M4OSA_MemAddr8)p_srcu, u_widthuv);\r
- M4OSA_memcpy((M4OSA_MemAddr8)p_destv, (M4OSA_MemAddr8)p_srcv, u_widthuv);\r
+ memcpy((void *)p_destu, (void *)p_srcu, u_widthuv);\r
+ memcpy((void *)p_destv, (void *)p_srcv, u_widthuv);\r
p_destu += u_stride_out_uv;\r
p_destv += u_stride_out_uv;\r
p_srcu += u_stride_uv;\r
/* the pointers to p_dest, p_destu and p_destv are used through the two loops "for" */\r
for (j = (u_height - nb_black_lines) >> 1; j != 0; j--)\r
{\r
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 0);\r
+ memset((void *)p_dest, 0,u_width);\r
p_dest += u_stride_out;\r
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 0);\r
+ memset((void *)p_dest, 0,u_width);\r
p_dest += u_stride_out;\r
- M4OSA_memset((M4OSA_MemAddr8)p_destu, u_widthuv, 128);\r
- M4OSA_memset((M4OSA_MemAddr8)p_destv, u_widthuv, 128);\r
+ memset((void *)p_destu, 128,u_widthuv);\r
+ memset((void *)p_destv, 128,u_widthuv);\r
p_destu += u_stride_out_uv;\r
p_destv += u_stride_out_uv;\r
}\r
p_buf_dest = &(PlaneOut[plane_number].pac_data[PlaneOut[plane_number].u_topleft]);\r
for (i = 0; i < PlaneOut[plane_number].u_height; i++)\r
{\r
- M4OSA_memcpy((M4OSA_MemAddr8)p_buf_dest, (M4OSA_MemAddr8)p_buf_src ,PlaneOut[plane_number].u_width);\r
+ memcpy((void *)p_buf_dest, (void *)p_buf_src ,PlaneOut[plane_number].u_width);\r
p_buf_src += PlaneIn[plane_number].u_stride;\r
p_buf_dest += PlaneOut[plane_number].u_stride;\r
}\r
Media rendering: Black borders*/\r
if(mediaRendering == M4xVSS_kBlackBorders)\r
{\r
- M4OSA_memset((M4OSA_MemAddr8)pPlaneOut[0].pac_data,(pPlaneOut[0].u_height*pPlaneOut[0].u_stride),Y_PLANE_BORDER_VALUE);\r
- M4OSA_memset((M4OSA_MemAddr8)pPlaneOut[1].pac_data,(pPlaneOut[1].u_height*pPlaneOut[1].u_stride),U_PLANE_BORDER_VALUE);\r
- M4OSA_memset((M4OSA_MemAddr8)pPlaneOut[2].pac_data,(pPlaneOut[2].u_height*pPlaneOut[2].u_stride),V_PLANE_BORDER_VALUE);\r
+ memset((void *)pPlaneOut[0].pac_data,Y_PLANE_BORDER_VALUE,(pPlaneOut[0].u_height*pPlaneOut[0].u_stride));\r
+ memset((void *)pPlaneOut[1].pac_data,U_PLANE_BORDER_VALUE,(pPlaneOut[1].u_height*pPlaneOut[1].u_stride));\r
+ memset((void *)pPlaneOut[2].pac_data,V_PLANE_BORDER_VALUE,(pPlaneOut[2].u_height*pPlaneOut[2].u_stride));\r
\r
pImagePlanesTemp[0].u_width = pPlaneOut[0].u_width;\r
pImagePlanesTemp[0].u_height = pPlaneOut[0].u_height;\r
pInPlaneU = pImagePlanesTemp[1].pac_data ;\r
pInPlaneV = pImagePlanesTemp[2].pac_data ;\r
\r
- M4OSA_memset((M4OSA_MemAddr8)pImagePlanesTemp[0].pac_data,(pImagePlanesTemp[0].u_height*pImagePlanesTemp[0].u_stride),Y_PLANE_BORDER_VALUE);\r
- M4OSA_memset((M4OSA_MemAddr8)pImagePlanesTemp[1].pac_data,(pImagePlanesTemp[1].u_height*pImagePlanesTemp[1].u_stride),U_PLANE_BORDER_VALUE);\r
- M4OSA_memset((M4OSA_MemAddr8)pImagePlanesTemp[2].pac_data,(pImagePlanesTemp[2].u_height*pImagePlanesTemp[2].u_stride),V_PLANE_BORDER_VALUE);\r
+ memset((void *)pImagePlanesTemp[0].pac_data,Y_PLANE_BORDER_VALUE,(pImagePlanesTemp[0].u_height*pImagePlanesTemp[0].u_stride));\r
+ memset((void *)pImagePlanesTemp[1].pac_data,U_PLANE_BORDER_VALUE,(pImagePlanesTemp[1].u_height*pImagePlanesTemp[1].u_stride));\r
+ memset((void *)pImagePlanesTemp[2].pac_data,V_PLANE_BORDER_VALUE,(pImagePlanesTemp[2].u_height*pImagePlanesTemp[2].u_stride));\r
\r
if((M4OSA_UInt32)((pPlaneIn->u_height * pPlaneOut->u_width) /pPlaneIn->u_width) <= pPlaneOut->u_height)//Params.m_inputSize.m_height < Params.m_inputSize.m_width)\r
{\r
{\r
for(i=0; i<pPlaneOut[0].u_height; i++)\r
{\r
- M4OSA_memcpy((M4OSA_MemAddr8)pOutPlaneY, (M4OSA_MemAddr8)pInPlaneY, pPlaneOut[0].u_width);\r
+ memcpy((void *)pOutPlaneY, (void *)pInPlaneY, pPlaneOut[0].u_width);\r
pInPlaneY += pPlaneOut[0].u_width;\r
pOutPlaneY += pPlaneOut[0].u_stride;\r
}\r
for(i=0; i<pPlaneOut[1].u_height; i++)\r
{\r
- M4OSA_memcpy((M4OSA_MemAddr8)pOutPlaneU, (M4OSA_MemAddr8)pInPlaneU, pPlaneOut[1].u_width);\r
+ memcpy((void *)pOutPlaneU, (void *)pInPlaneU, pPlaneOut[1].u_width);\r
pInPlaneU += pPlaneOut[1].u_width;\r
pOutPlaneU += pPlaneOut[1].u_stride;\r
}\r
for(i=0; i<pPlaneOut[2].u_height; i++)\r
{\r
- M4OSA_memcpy((M4OSA_MemAddr8)pOutPlaneV, (M4OSA_MemAddr8)pInPlaneV, pPlaneOut[2].u_width);\r
+ memcpy((void *)pOutPlaneV, (void *)pInPlaneV, pPlaneOut[2].u_width);\r
pInPlaneV += pPlaneOut[2].u_width;\r
pOutPlaneV += pPlaneOut[2].u_stride;\r
}\r
for (j=0; j<loc_height; j++)\r
{\r
/**< Copy one whole line */\r
- memcpy((M4OSA_MemAddr8)pu8_data_out, (M4OSA_MemAddr8)pu8_data_in, loc_width);\r
+ memcpy((void *)pu8_data_out, (void *)pu8_data_in, loc_width);\r
\r
/**< Update pointers */\r
pu8_data_out += pOut[i].u_stride;\r
M4OSAL_MEMORY_EXPORT_TYPE extern M4OSA_Void M4OSA_free (M4OSA_MemAddr32 address);
-M4OSAL_MEMORY_EXPORT_TYPE extern M4OSA_Void M4OSA_memset (M4OSA_MemAddr8 address,
- M4OSA_UInt32 size,
- M4OSA_UInt8 value);
-
-M4OSAL_MEMORY_EXPORT_TYPE extern M4OSA_Void M4OSA_memcpy (M4OSA_MemAddr8 outputBlock,
- M4OSA_MemAddr8 inputBlock, M4OSA_UInt32 size);
-
-M4OSAL_MEMORY_EXPORT_TYPE extern M4OSA_MemAddr8 M4OSA_memmove(M4OSA_MemAddr8 outputBlock,
- M4OSA_MemAddr8 inputBlock,
- M4OSA_UInt32 size);
-
-M4OSAL_MEMORY_EXPORT_TYPE extern M4OSA_Int32 M4OSA_memcmp (M4OSA_MemAddr8 address1,
- M4OSA_MemAddr8 address2, M4OSA_UInt32 size);
M4OSAL_MEMORY_EXPORT_TYPE extern M4OSA_ERR M4OSA_randInit(void);
copysize = apContext->buffer[i].size - offset;
copysize = (size < copysize) ? size : copysize;
- M4OSA_memcpy(pData, apContext->buffer[i].data + offset, copysize);
+ memcpy((void *)pData, (void *)(apContext->buffer[i].data + offset), copysize);
apContext->buffer[i].remain -= copysize;
apContext->buffer[i].nbFillSinceLastAcess = 0;
return M4ERR_ALLOC;
}
- M4OSA_memcpy((M4OSA_MemAddr8)threadContext->name, (M4OSA_MemAddr8)name,
+ memcpy((void *)threadContext->name, (void *)name,
nameSize);
}
free(address);
}
-
-/**
- ************************************************************************
- * @fn M4OSA_Void M4OSA_memset(M4OSA_MemAddr8 block,
- * M4OSA_UInt32 size,
- * M4OSA_UInt8 value)
- * @brief this function initializes the provided memory block with value
- * @note
- * @param block (IN): address of block to fill
- * @param size (IN): size of the provided block
- * @param value (IN): value used for initialization
- * @return none
- ************************************************************************
-*/
-
-M4OSA_Void M4OSA_memset(M4OSA_MemAddr8 block,
- M4OSA_UInt32 size,
- M4OSA_UInt8 value)
-{
- memset((void*)block, value, size);
-}
-
-
-/**
- ************************************************************************
- * @fn M4OSA_Void M4OSA_memcpy(M4OSA_MemAddr8 outputBlock,
- * M4OSA_MemAddr8 inputBlock,
- * M4OSA_UInt32 size)
- * @brief this function copies 'size' bytes from inputBlock to outputBlock
- * @note
- * @param outputBlock (IN): address of block to fill
- * @param inputBlock (IN): address of the input block
- * @param size (IN): size of the block to copy (in bytes)
- * @return none
- ************************************************************************
-*/
-
-M4OSA_Void M4OSA_memcpy(M4OSA_MemAddr8 outputBlock,
- M4OSA_MemAddr8 inputBlock,
- M4OSA_UInt32 size)
-{
- memcpy((void*)outputBlock, (void*)inputBlock, size);
-}
-
-/**
- ************************************************************************
- * @fn M4OSA_MemAddr8 M4OSA_memmove(M4OSA_MemAddr8 outputBlock, M4OSA_MemAddr8 inputBlock, M4OSA_UInt32 size)
- * @brief this function moves 'size' bytes from inputBlock to outputBlock
- * unlike M4OSA_memcpy, the two buffers can have an overlap.
- * @note increment memcpy byte number (François VALETTE)
- * @param outputBlock (IN): address of block to fill
- * @param inputBlock (IN): address of the input block
- * @param size (IN): size of the block to copy (in bytes)
- * @return address of the output block, i.e. the first parameter
- ************************************************************************
-*/
-M4OSA_MemAddr8 M4OSA_memmove(M4OSA_MemAddr8 outputBlock,
- M4OSA_MemAddr8 inputBlock,
- M4OSA_UInt32 size)
-{
- return memmove((void*)outputBlock, (void*)inputBlock, size);
-}
-
-/**
- ************************************************************************
- * @fn M4OSA_Int32 M4OSA_memcmp(M4OSA_MemAddr8 address1, M4OSA_MemAddr8 address2, M4OSA_UInt32 size)
- * @brief this function compares the first 'size' bytes of address1 and
- 'address2' and return a value indicating their relationship.
- * @note
- * @param address1 (IN): memory address 1
- * @param address2 (IN): memory address 2
- * @param size (IN): size of the block to compare (in bytes)
- * @return +1, if first bytes of adress1 are smaller than those of address2
- * @return 0, if both blocks are identical
- * @return -1, if first bytes of address1 are bigger than those of address2
- ************************************************************************
-*/
-
-M4OSA_Int32 M4OSA_memcmp(M4OSA_MemAddr8 address1,
- M4OSA_MemAddr8 address2,
- M4OSA_UInt32 size)
-{
- M4OSA_Int32 i32_result = memcmp(address1, address2, size);
- if (i32_result > 0) {
- return 1;
- }
- else if (i32_result < 0) {
- return((M4OSA_Int32)-1);
- }
- return 0;
-}
-
-
-
-
#endif
(M4OSA_Char *)"realloc");
if (M4OSA_NULL != ptr2)
{
- M4OSA_memcpy((M4OSA_MemAddr8)ptr2, (M4OSA_MemAddr8)ptr, oldSize);
+ memcpy((void *)ptr2, (void *)ptr, oldSize);
}
M4OSA_free(ptr);
return ptr2;
/* ftyp atom */
- M4OSA_memset((M4OSA_MemAddr8) &mMp4FileDataPtr->ftyp,
- sizeof(mMp4FileDataPtr->ftyp), 0);
+ memset((void *) &mMp4FileDataPtr->ftyp,0,
+ sizeof(mMp4FileDataPtr->ftyp));
*contextPtr = mMp4FileDataPtr;
(M4OSA_Char *)"audioTrackPtr->DSI");
ERR_CHECK(mMp4FileDataPtr->audioTrackPtr->DSI != M4OSA_NULL,
M4ERR_ALLOC);
- M4OSA_memcpy(
- (M4OSA_MemAddr8)mMp4FileDataPtr->audioTrackPtr->DSI,
- (M4OSA_MemAddr8)streamDescPtr->decoderSpecificInfo,
+ memcpy(
+ (void *)mMp4FileDataPtr->audioTrackPtr->DSI,
+ (void *)streamDescPtr->decoderSpecificInfo,
9);
}
else
(M4OSA_Char *)"audioTrackPtr->DSI");
ERR_CHECK(mMp4FileDataPtr->audioTrackPtr->DSI != M4OSA_NULL,
M4ERR_ALLOC);
- M4OSA_memcpy(
- (M4OSA_MemAddr8)mMp4FileDataPtr->audioTrackPtr->DSI,
- (M4OSA_MemAddr8)streamDescPtr->decoderSpecificInfo,
+ memcpy(
+ (void *)mMp4FileDataPtr->audioTrackPtr->DSI,
+ (void *)streamDescPtr->decoderSpecificInfo,
6);
}
else
M4MP4_WRITER, (M4OSA_Char *)"audioTrackPtr->DSI");
ERR_CHECK(mMp4FileDataPtr->audioTrackPtr->DSI != M4OSA_NULL,
M4ERR_ALLOC);
- M4OSA_memcpy(
- (M4OSA_MemAddr8)mMp4FileDataPtr->audioTrackPtr->DSI,
- (M4OSA_MemAddr8)streamDescPtr->decoderSpecificInfo,
+ memcpy(
+ (void *)mMp4FileDataPtr->audioTrackPtr->DSI,
+ (void *)streamDescPtr->decoderSpecificInfo,
streamDescPtr->decoderSpecificInfoSize);
}
else
M4MP4_WRITER, (M4OSA_Char *)"videoTrackPtr->DSI");
ERR_CHECK(mMp4FileDataPtr->videoTrackPtr->DSI != M4OSA_NULL,
M4ERR_ALLOC);
- M4OSA_memcpy(
- (M4OSA_MemAddr8)mMp4FileDataPtr->videoTrackPtr->DSI,
- (M4OSA_MemAddr8)streamDescPtr->decoderSpecificInfo,
+ memcpy(
+ (void *)mMp4FileDataPtr->videoTrackPtr->DSI,
+ (void *)streamDescPtr->decoderSpecificInfo,
streamDescPtr->decoderSpecificInfoSize);
}
else
M4MP4_WRITER, (M4OSA_Char *)"videoTrackPtr->DSI");
ERR_CHECK(mMp4FileDataPtr->videoTrackPtr->DSI != M4OSA_NULL,
M4ERR_ALLOC);
- M4OSA_memcpy(
- (M4OSA_MemAddr8)mMp4FileDataPtr->videoTrackPtr->DSI,
- (M4OSA_MemAddr8)streamDescPtr->decoderSpecificInfo,
+ memcpy(
+ (void *)mMp4FileDataPtr->videoTrackPtr->DSI,
+ (void *)streamDescPtr->decoderSpecificInfo,
streamDescPtr->decoderSpecificInfoSize);
mMp4FileDataPtr->filesize +=
streamDescPtr->decoderSpecificInfoSize;
(M4OSA_UInt16 *)streamDescPtr->decoderSpecificInfo;
SPSLength = DSI[6];
PPSLength = DSI[10];
- M4OSA_memcpy(
- (M4OSA_MemAddr8)mMp4FileDataPtr->videoTrackPtr->DSI,
- (M4OSA_MemAddr8)(streamDescPtr->
- decoderSpecificInfo)+12, 2);
- M4OSA_memcpy(
- (M4OSA_MemAddr8)(mMp4FileDataPtr->videoTrackPtr->
- DSI)+2, (M4OSA_MemAddr8)(streamDescPtr->
- decoderSpecificInfo)+28, SPSLength);
-
- M4OSA_memcpy(
- (M4OSA_MemAddr8)(mMp4FileDataPtr->videoTrackPtr->
- DSI)+2 + SPSLength,
- (M4OSA_MemAddr8)(streamDescPtr->
- decoderSpecificInfo)+20, 2);
- M4OSA_memcpy(
- (M4OSA_MemAddr8)(mMp4FileDataPtr->videoTrackPtr->
- DSI)+4 + SPSLength,
- (M4OSA_MemAddr8)(streamDescPtr->
- decoderSpecificInfo)+28 + SPSLength,
+ memcpy(
+ (void *)mMp4FileDataPtr->videoTrackPtr->DSI,
+ (void *)((streamDescPtr->
+ decoderSpecificInfo)+12), 2);
+ memcpy(
+ (void *)((mMp4FileDataPtr->videoTrackPtr->
+ DSI)+2), (void *)((streamDescPtr->
+ decoderSpecificInfo)+28), SPSLength);
+
+ memcpy(
+ (void *)((mMp4FileDataPtr->videoTrackPtr->
+ DSI)+2 + SPSLength),
+ (void *)((streamDescPtr->
+ decoderSpecificInfo)+20), 2);
+ memcpy(
+ (void *)((mMp4FileDataPtr->videoTrackPtr->
+ DSI)+4 + SPSLength),
+ (void *)((streamDescPtr->
+ decoderSpecificInfo)+28 + SPSLength),
PPSLength);
/* - H.264 trimming */
}
M4MP4_WRITER, (M4OSA_Char *)"videoTrackPtr->DSI");
ERR_CHECK(mMp4FileDataPtr->videoTrackPtr->DSI
!= M4OSA_NULL, M4ERR_ALLOC);
- M4OSA_memcpy(
- (M4OSA_MemAddr8)mMp4FileDataPtr->videoTrackPtr->DSI,
- (M4OSA_MemAddr8)streamDescPtr->
+ memcpy(
+ (void *)mMp4FileDataPtr->videoTrackPtr->DSI,
+ (void *)streamDescPtr->
decoderSpecificInfo,
streamDescPtr->decoderSpecificInfoSize);
}
safetyFileSize += mMp4FileDataPtr->audioTrackPtr->MaxChunkSize;
}
- M4OSA_memset(dummyData, sizeof(dummyData),
- 0xCA); /* For extra safety. */
+ memset((void *)dummyData, 0xCA,sizeof(dummyData)); /* For extra safety. */
for ( i = 0;
i < (safetyFileSize + sizeof(dummyData) - 1) / sizeof(dummyData);
memAddrPtr->size = 16;
/*if no value was set, return the default string */
if (mMp4FileDataPtr->embeddedString != M4OSA_NULL)
- M4OSA_memcpy((M4OSA_MemAddr8)memAddrPtr->addr,
- (M4OSA_MemAddr8)mMp4FileDataPtr->embeddedString, 16);
+ memcpy((void *)memAddrPtr->addr,
+ (void *)mMp4FileDataPtr->embeddedString, 16);
else
- M4OSA_memcpy((M4OSA_MemAddr8)memAddrPtr->addr,
- (M4OSA_MemAddr8)BlockSignatureSkipDefaultEmbeddedString,
+ memcpy((void *)memAddrPtr->addr,
+ (void *)BlockSignatureSkipDefaultEmbeddedString,
16);
break;
memAddrPtr->size = 60;
/*if no value was set, return the default string 0 */
if (mMp4FileDataPtr->integrationTag != M4OSA_NULL)
- M4OSA_memcpy((M4OSA_MemAddr8)memAddrPtr->addr,
- (M4OSA_MemAddr8)mMp4FileDataPtr->integrationTag, 60);
+ memcpy((void *)memAddrPtr->addr,
+ (void *)mMp4FileDataPtr->integrationTag, 60);
else
- M4OSA_memcpy((M4OSA_MemAddr8)memAddrPtr->addr,
- (M4OSA_MemAddr8)BlockSignatureSkipDefaultIntegrationTag,
+ memcpy((void *)memAddrPtr->addr,
+ (void *)BlockSignatureSkipDefaultIntegrationTag,
60);
break;
M4ERR_ALLOC);
}
/*else, just overwrite the previously set string*/
- M4OSA_memcpy((M4OSA_MemAddr8)mMp4FileDataPtr->embeddedString,
- (M4OSA_MemAddr8)memAddrPtr->addr, 16);
+ memcpy((void *)mMp4FileDataPtr->embeddedString,
+ (void *)memAddrPtr->addr, 16);
break;
case (M4MP4W_integrationTag):
/*else, just overwrite the previously set string*/
if (memAddrPtr->size < 60)
{
- M4OSA_memcpy((M4OSA_MemAddr8)mMp4FileDataPtr->integrationTag,
- (M4OSA_MemAddr8)BlockSignatureSkipDefaultIntegrationTag,
+ memcpy((void *)mMp4FileDataPtr->integrationTag,
+ (void *)BlockSignatureSkipDefaultIntegrationTag,
60);
- M4OSA_memcpy((M4OSA_MemAddr8)mMp4FileDataPtr->integrationTag,
- (M4OSA_MemAddr8)memAddrPtr->addr, memAddrPtr->size);
+ memcpy((void *)mMp4FileDataPtr->integrationTag,
+ (void *)memAddrPtr->addr, memAddrPtr->size);
}
else
{
- M4OSA_memcpy((M4OSA_MemAddr8)mMp4FileDataPtr->integrationTag,
- (M4OSA_MemAddr8)memAddrPtr->addr, 60);
+ memcpy((void *)mMp4FileDataPtr->integrationTag,
+ (void *)memAddrPtr->addr, 60);
}
break;
M4MP4_WRITER, (M4OSA_Char *)"videoTrackPtr->DSI");
ERR_CHECK(mMp4FileDataPtr->videoTrackPtr->DSI
!= M4OSA_NULL, M4ERR_ALLOC);
- M4OSA_memcpy(
- (M4OSA_MemAddr8)mMp4FileDataPtr->videoTrackPtr->
+ memcpy(
+ (void *)mMp4FileDataPtr->videoTrackPtr->
DSI,
- (M4OSA_MemAddr8)streamIDmemAddrPtr->addr,
+ (void *)streamIDmemAddrPtr->addr,
streamIDmemAddrPtr->size);
break;
M4MP4_WRITER, (M4OSA_Char *)"videoTrackPtr->DSI");
ERR_CHECK(mMp4FileDataPtr->videoTrackPtr->DSI
!= M4OSA_NULL, M4ERR_ALLOC);
- M4OSA_memcpy(
- (M4OSA_MemAddr8)mMp4FileDataPtr->videoTrackPtr->
+ memcpy(
+ (void *)mMp4FileDataPtr->videoTrackPtr->
DSI,
- (M4OSA_MemAddr8)streamIDmemAddrPtr->addr,
+ (void *)streamIDmemAddrPtr->addr,
streamIDmemAddrPtr->size);
mMp4FileDataPtr->filesize +=
streamIDmemAddrPtr->size;
(M4OSA_Char *)"videoTrackPtr->DSI");
ERR_CHECK(mMp4FileDataPtr->videoTrackPtr->DSI !=
M4OSA_NULL, M4ERR_ALLOC);
- M4OSA_memcpy(
- (M4OSA_MemAddr8)mMp4FileDataPtr->videoTrackPtr->DSI,
- (M4OSA_MemAddr8)streamIDmemAddrPtr->addr,
+ memcpy(
+ (void *)mMp4FileDataPtr->videoTrackPtr->DSI,
+ (void *)streamIDmemAddrPtr->addr,
streamIDmemAddrPtr->size);
break;
M4MP4_WRITER, (M4OSA_Char *)"videoTrackPtr->DSI");
ERR_CHECK(mMp4FileDataPtr->videoTrackPtr->DSI
!= M4OSA_NULL, M4ERR_ALLOC);
- M4OSA_memcpy(
- (M4OSA_MemAddr8)mMp4FileDataPtr->videoTrackPtr->
+ memcpy(
+ (void *)mMp4FileDataPtr->videoTrackPtr->
DSI,
- (M4OSA_MemAddr8)streamIDmemAddrPtr->addr,
+ (void *)streamIDmemAddrPtr->addr,
streamIDmemAddrPtr->size);
break;
// StageFright codecs may add a start code, make sure it is not present
- if( !M4OSA_memcmp((M4OSA_MemAddr8)inbuff,
- (M4OSA_MemAddr8)"\x00\x00\x00\x01", 4) )
+ if( !memcmp((void *)inbuff,
+ "\x00\x00\x00\x01", 4) )
{
M4OSA_TRACE1_3(
"H264MCS_ProcessNALU ERROR : NALU start code has not been removed %d "
// StageFright encoder does not provide the size in the first 4 bytes of the AU, add it
pTmpBuff1 = (M4OSA_Int8 *)M4OSA_malloc(inbuf_size + 4, M4MCS,
(M4OSA_Char *)"tmpNALU");
- M4OSA_memcpy((M4OSA_MemAddr8)(pTmpBuff1 + 4), (M4OSA_MemAddr8)inbuff,
+ memcpy((void *)(pTmpBuff1 + 4), (void *)inbuff,
inbuf_size);
pTmpBuff1[3] = ( (M4OSA_UInt32)inbuf_size) & 0x000000FF;
pTmpBuff1[2] = ( (M4OSA_UInt32)inbuf_size >> 8) & 0x000000FF;
}
instance->m_pFinalDSISize = instance->m_decoderSpecificInfoSize;
- M4OSA_memcpy((M4OSA_MemAddr8)instance->m_pFinalDSI,
- (M4OSA_MemAddr8)instance->m_pDecoderSpecificInfo,
+ memcpy((void *)instance->m_pFinalDSI,
+ (void *)instance->m_pDecoderSpecificInfo,
instance->m_decoderSpecificInfoSize);
}
else
return M4ERR_ALLOC;
}
- M4OSA_memcpy((M4OSA_MemAddr8)instance->m_pFinalDSI,
- (M4OSA_MemAddr8)instance->m_pDecoderSpecificInfo,
+ memcpy((void *)instance->m_pFinalDSI,
+ (void *)instance->m_pDecoderSpecificInfo,
instance->m_decoderSpecificInfoSize);
temp = instance->m_pFinalDSI[lClipDSI_PPS_offset];
else
{
p_bs->Buffer = p_bs->Buffer - 5;
- M4OSA_memcpy((M4OSA_MemAddr8) &outbuff[outbuffpos],
- (M4OSA_MemAddr8)p_bs->Buffer, nal_size + 4);
+ memcpy((void *) &outbuff[outbuffpos],
+ (void *)p_bs->Buffer, nal_size + 4);
outbuff[outbuffpos] = (M4OSA_UInt8)((nal_size >> 24)& 0xFF);
outbuff[outbuffpos + 1] = (M4OSA_UInt8)((nal_size >> 16)& 0xFF);;
M4OSA_TRACE1_0("instance->m_pFinalDSI: allocation error");
return M4ERR_ALLOC;
}
- M4OSA_memcpy((M4OSA_MemAddr8)pC->m_pInstance->m_pFinalDSI,
- (M4OSA_MemAddr8)pC-> \
+ memcpy((void *)pC->m_pInstance->m_pFinalDSI,
+ (void *)pC-> \
m_pInstance->m_pDecoderSpecificInfo,
pC->m_pInstance->m_decoderSpecificInfoSize);
}
/**
* Copy previously computed properties into given structure */
- M4OSA_memcpy((M4OSA_MemAddr8)pFileProperties,
- (M4OSA_MemAddr8) &pC->InputFileProperties,
+ memcpy((void *)pFileProperties,
+ (void *) &pC->InputFileProperties,
sizeof(M4VIDEOEDITING_ClipProperties));
return M4NO_ERROR;
for ( j = 0; j < pC->nbEffects; j++ )
{
/* Copy effect to "local" structure */
- M4OSA_memcpy((M4OSA_MemAddr8) &(pC->pEffects[j]),
- (M4OSA_MemAddr8) &(pParams->pEffects[j]),
+ memcpy((void *) &(pC->pEffects[j]),
+ (void *) &(pParams->pEffects[j]),
sizeof(M4MCS_EffectSettings));
switch( pC->pEffects[j].AudioEffectType )
}
/* Copy Reading DSI to new DSI */
- M4OSA_memcpy(pC->WriterVideoStreamInfo.Header.pBuf,
- pC->pReaderVideoStream->
+ memcpy((void *)pC->WriterVideoStreamInfo.Header.pBuf,
+ (void *)pC->pReaderVideoStream->
m_basicProperties.m_pDecoderSpecificInfo,
pC->WriterVideoStreamInfo.Header.Size);
pC->ReaderAudioAU1.m_maxsize;
}
/**/
- M4OSA_memcpy((M4OSA_MemAddr8)pC->m_pDataAddress1,
- (M4OSA_MemAddr8)pC->ReaderAudioAU1.m_dataAddress,
+ memcpy((void *)pC->m_pDataAddress1,
+ (void *)pC->ReaderAudioAU1.m_dataAddress,
pC->ReaderAudioAU1.m_size);
}
* Read the next audio AU in the input file */
if( pC->ReaderAudioAU2.m_CTS > pC->ReaderAudioAU1.m_CTS )
{
- M4OSA_memcpy((M4OSA_MemAddr8) &pC->ReaderAudioAU,
- (M4OSA_MemAddr8) &pC->ReaderAudioAU2, sizeof(M4_AccessUnit));
+ memcpy((void *) &pC->ReaderAudioAU,
+ (void *) &pC->ReaderAudioAU2, sizeof(M4_AccessUnit));
err = pC->m_pReaderDataIt->m_pFctGetNextAu(pC->pReaderContext,
(M4_StreamHandler *)pC->pReaderAudioStream,
&pC->ReaderAudioAU1);
pC->ReaderAudioAU1.m_maxsize;
}
/**/
- M4OSA_memcpy((M4OSA_MemAddr8)pC->m_pDataAddress1,
- (M4OSA_MemAddr8)pC->ReaderAudioAU1.m_dataAddress,
+ memcpy((void *)pC->m_pDataAddress1,
+ (void *)pC->ReaderAudioAU1.m_dataAddress,
pC->ReaderAudioAU1.m_size);
pC->m_audioAUDuration =
pC->ReaderAudioAU1.m_CTS - pC->ReaderAudioAU2.m_CTS;
}
else
{
- M4OSA_memcpy((M4OSA_MemAddr8) &pC->ReaderAudioAU,
- (M4OSA_MemAddr8) &pC->ReaderAudioAU1, sizeof(M4_AccessUnit));
+ memcpy((void *) &pC->ReaderAudioAU,
+ (void *) &pC->ReaderAudioAU1, sizeof(M4_AccessUnit));
err = pC->m_pReaderDataIt->m_pFctGetNextAu(pC->pReaderContext,
(M4_StreamHandler *)pC->pReaderAudioStream,
&pC->ReaderAudioAU2);
pC->ReaderAudioAU2.m_maxsize;
}
/**/
- M4OSA_memcpy((M4OSA_MemAddr8)pC->m_pDataAddress2,
- (M4OSA_MemAddr8)pC->ReaderAudioAU2.m_dataAddress,
+ memcpy((void *)pC->m_pDataAddress2,
+ (void *)pC->ReaderAudioAU2.m_dataAddress,
pC->ReaderAudioAU2.m_size);
pC->m_audioAUDuration =
pC->ReaderAudioAU2.m_CTS - pC->ReaderAudioAU1.m_CTS;
if( pC->InputFileProperties.uiNbChannels == 1 )
{
pC->WriterAudioAU.size = M4VSS3GPP_AAC_AU_SILENCE_MONO_SIZE;
- M4OSA_memcpy((M4OSA_MemAddr8)pC->WriterAudioAU.dataAddress,
- (M4OSA_MemAddr8)M4VSS3GPP_AAC_AU_SILENCE_MONO,
+ memcpy((void *)pC->WriterAudioAU.dataAddress,
+ (void *)M4VSS3GPP_AAC_AU_SILENCE_MONO,
pC->WriterAudioAU.size);
}
else if( pC->InputFileProperties.uiNbChannels == 2 )
{
pC->WriterAudioAU.size = M4VSS3GPP_AAC_AU_SILENCE_STEREO_SIZE;
- M4OSA_memcpy((M4OSA_MemAddr8)pC->WriterAudioAU.dataAddress,
- (M4OSA_MemAddr8)M4VSS3GPP_AAC_AU_SILENCE_STEREO,
+ memcpy((void *)pC->WriterAudioAU.dataAddress,
+ (void *)M4VSS3GPP_AAC_AU_SILENCE_STEREO,
pC->WriterAudioAU.size);
}
else
== M4VIDEOEDITING_kAMR_NB )
{
pC->WriterAudioAU.size = M4VSS3GPP_AMR_AU_SILENCE_FRAME_048_SIZE;
- M4OSA_memcpy((M4OSA_MemAddr8)pC->WriterAudioAU.dataAddress,
- (M4OSA_MemAddr8)M4VSS3GPP_AMR_AU_SILENCE_FRAME_048,
+ memcpy((void *)pC->WriterAudioAU.dataAddress,
+ (void *)M4VSS3GPP_AMR_AU_SILENCE_FRAME_048,
pC->WriterAudioAU.size);
/* Some remaining AMR AU needs to be copied */
if( pC->ReaderAudioAU.m_size != 0 )
{
/* Update Writer AU */
pC->WriterAudioAU.size += pC->ReaderAudioAU.m_size;
- M4OSA_memcpy((M4OSA_MemAddr8)pC->WriterAudioAU.dataAddress
- + M4VSS3GPP_AMR_AU_SILENCE_FRAME_048_SIZE,
- (M4OSA_MemAddr8)pC->ReaderAudioAU.m_dataAddress,
+ memcpy((void *)(pC->WriterAudioAU.dataAddress
+ + M4VSS3GPP_AMR_AU_SILENCE_FRAME_048_SIZE),
+ (void *)pC->ReaderAudioAU.m_dataAddress,
pC->ReaderAudioAU.m_size);
}
}
M4OSA_TRACE3_1(
"M4MCS_intAudioNullEncoding(): Copying audio AU: size=%d",
pC->ReaderAudioAU.m_size);
- M4OSA_memcpy((M4OSA_MemAddr8)pC->WriterAudioAU.dataAddress,
- (M4OSA_MemAddr8)pC->ReaderAudioAU.m_dataAddress,
+ memcpy((void *)pC->WriterAudioAU.dataAddress,
+ (void *)pC->ReaderAudioAU.m_dataAddress,
pC->ReaderAudioAU.m_size);
pC->WriterAudioAU.size = pC->ReaderAudioAU.m_size;
}
M4OSA_TRACE3_1(
"M4MCS_intAudioNullEncoding(): Copying audio AU: size=%d",
pC->ReaderAudioAU.m_size);
- M4OSA_memcpy((M4OSA_MemAddr8)pC->WriterAudioAU.dataAddress,
- (M4OSA_MemAddr8)pC->ReaderAudioAU.m_dataAddress,
+ memcpy((void *)pC->WriterAudioAU.dataAddress,
+ (void *)pC->ReaderAudioAU.m_dataAddress,
pC->ReaderAudioAU.m_size);
pC->WriterAudioAU.size = pC->ReaderAudioAU.m_size;
}
/**
* Copy from the decoder out buffer into the Ssrc in buffer */
- M4OSA_memcpy(pC->pPosInSsrcBufferIn, pC->pPosInDecBufferOut,
+ memcpy((void *)pC->pPosInSsrcBufferIn, (void *)pC->pPosInDecBufferOut,
uiDecoder2Ssrc_NbBytes);
/**
(short *)M4OSA_malloc((pC->iSsrcNbSamplOut * sizeof(short) * 2
* ((*pC).InputFileProperties).uiNbChannels),
M4VSS3GPP,(M4OSA_Char *) "tempBuffOut");
- M4OSA_memset((M4OSA_MemAddr8)tempBuffOut, (pC->iSsrcNbSamplOut * sizeof(short) * 2
- * ((*pC).InputFileProperties).uiNbChannels), 0);
+ memset((void *)tempBuffOut, 0,(pC->iSsrcNbSamplOut * sizeof(short) * 2
+ * ((*pC).InputFileProperties).uiNbChannels));
LVAudioresample_LowQuality((short *)tempBuffOut, (short *)pSsrcInput,
pC->iSsrcNbSamplOut, pC->pLVAudioResampler);
}
else
{
- M4OSA_memset(pC->pSsrcBufferOut, (pC->iSsrcNbSamplOut * sizeof(short)
- * ((*pC).InputFileProperties).uiNbChannels), 0);
+ memset((void *)pC->pSsrcBufferOut, 0, (pC->iSsrcNbSamplOut * sizeof(short)
+ * ((*pC).InputFileProperties).uiNbChannels));
LVAudioresample_LowQuality((short *)pC->pSsrcBufferOut,
(short *)pSsrcInput, pC->iSsrcNbSamplOut, pC->pLVAudioResampler);
else
{
/* copy from the ssrc out buffer into the encoder in buffer */
- M4OSA_memcpy(pC->pPosInAudioEncoderBuffer, pC->pPosInSsrcBufferOut,
+ memcpy((void *)pC->pPosInAudioEncoderBuffer, (void *)pC->pPosInSsrcBufferOut,
uiSsrc2Encoder_NbBytes);
}
pC->pReaderVideoStream->m_basicProperties.m_maxAUSize =
pC->ReaderVideoAU1.m_maxsize;
}
- M4OSA_memcpy((M4OSA_MemAddr8)pC->m_pDataVideoAddress1,
- (M4OSA_MemAddr8)pC->ReaderVideoAU1.m_dataAddress,
+ memcpy((void *)pC->m_pDataVideoAddress1,
+ (void *)pC->ReaderVideoAU1.m_dataAddress,
pC->ReaderVideoAU1.m_size);
}
* Read the next video AU in the input file */
if( pC->ReaderVideoAU2.m_CTS > pC->ReaderVideoAU1.m_CTS )
{
- M4OSA_memcpy((M4OSA_MemAddr8) &pC->ReaderVideoAU,
- (M4OSA_MemAddr8) &pC->ReaderVideoAU2, sizeof(M4_AccessUnit));
+ memcpy((void *) &pC->ReaderVideoAU,
+ (void *) &pC->ReaderVideoAU2, sizeof(M4_AccessUnit));
err = pC->m_pReaderDataIt->m_pFctGetNextAu(pC->pReaderContext,
(M4_StreamHandler *)pC->pReaderVideoStream,
&pC->ReaderVideoAU1);
pC->pReaderVideoStream->m_basicProperties.m_maxAUSize =
pC->ReaderVideoAU1.m_maxsize;
}
- M4OSA_memcpy((M4OSA_MemAddr8)pC->m_pDataVideoAddress1,
- (M4OSA_MemAddr8)pC->ReaderVideoAU1.m_dataAddress,
+ memcpy((void *)pC->m_pDataVideoAddress1,
+ (void *)pC->ReaderVideoAU1.m_dataAddress,
pC->ReaderVideoAU1.m_size);
videoAUDuration = pC->ReaderVideoAU1.m_CTS - pC->ReaderVideoAU2.m_CTS;
pC->ReaderVideoAU.m_dataAddress = pC->m_pDataVideoAddress2;
}
else
{
- M4OSA_memcpy((M4OSA_MemAddr8) &pC->ReaderVideoAU,
- (M4OSA_MemAddr8) &pC->ReaderVideoAU1, sizeof(M4_AccessUnit));
+ memcpy((void *) &pC->ReaderVideoAU,
+ (void *) &pC->ReaderVideoAU1, sizeof(M4_AccessUnit));
err = pC->m_pReaderDataIt->m_pFctGetNextAu(pC->pReaderContext,
(M4_StreamHandler *)pC->pReaderVideoStream,
&pC->ReaderVideoAU2);
pC->pReaderVideoStream->m_basicProperties.m_maxAUSize =
pC->ReaderVideoAU2.m_maxsize;
}
- M4OSA_memcpy((M4OSA_MemAddr8)pC->m_pDataVideoAddress2,
- (M4OSA_MemAddr8)pC->ReaderVideoAU2.m_dataAddress,
+ memcpy((void *)pC->m_pDataVideoAddress2,
+ (void *)pC->ReaderVideoAU2.m_dataAddress,
pC->ReaderVideoAU2.m_size);
videoAUDuration = pC->ReaderVideoAU2.m_CTS - pC->ReaderVideoAU1.m_CTS;
pC->ReaderVideoAU.m_dataAddress = pC->m_pDataVideoAddress1;
{
/**
* Copy video data from reader AU to writer AU */
- //M4OSA_memcpy((M4OSA_MemAddr8)pC->WriterVideoAU.dataAddress,
+ //memcpy((M4OSA_MemAddr8)pC->WriterVideoAU.dataAddress,
//(M4OSA_MemAddr8)pC->ReaderVideoAU.m_dataAddress, pC->ReaderVideoAU.m_size);
pC->WriterVideoAU.size = pC->ReaderVideoAU.m_size;
(M4OSA_UInt8 *)pC->ReaderVideoAU.m_dataAddress ,
pC->ReaderVideoAU.m_size);
- M4OSA_memcpy((M4OSA_MemAddr8)pC->WriterVideoAU.dataAddress,
- (M4OSA_MemAddr8)(pC->ReaderVideoAU.m_dataAddress + 4),
+ memcpy((void *)pC->WriterVideoAU.dataAddress,
+ (void *)(pC->ReaderVideoAU.m_dataAddress + 4),
pC->ReaderVideoAU.m_size - 4);
pC->WriterVideoAU.size = pC->ReaderVideoAU.m_size - 4;
WritebufferAdd =
}
else
{
- M4OSA_memcpy((M4OSA_MemAddr8)pC->WriterVideoAU.dataAddress,
- (M4OSA_MemAddr8)(pC->H264MCSTempBuffer + 4),
+ memcpy((void *)pC->WriterVideoAU.dataAddress,
+ (void *)(pC->H264MCSTempBuffer + 4),
pC->H264MCSTempBufferDataSize - 4);
pC->WriterVideoAU.size = pC->H264MCSTempBufferDataSize - 4;
WritebufferAdd =
/* H.264 Trimming */
else
{
- M4OSA_memcpy((M4OSA_MemAddr8)pC->WriterVideoAU.dataAddress,
- (M4OSA_MemAddr8)pC->ReaderVideoAU.m_dataAddress,
+ memcpy((void *)pC->WriterVideoAU.dataAddress,
+ (void *)pC->ReaderVideoAU.m_dataAddress,
pC->ReaderVideoAU.m_size);
pC->WriterVideoAU.size = pC->ReaderVideoAU.m_size;
}
{
if( pC->m_pInstance->is_done == 1 )
{
- M4OSA_memcpy((M4OSA_MemAddr8)(WritebufferAdd - 4),
- (M4OSA_MemAddr8)(pC->ReaderVideoAU.m_dataAddress), 4);
+ memcpy((void *)(WritebufferAdd - 4),
+ (void *)(pC->ReaderVideoAU.m_dataAddress), 4);
}
else
{
- M4OSA_memcpy((M4OSA_MemAddr8)(WritebufferAdd - 4),
- (M4OSA_MemAddr8)(pC->H264MCSTempBuffer), 4);
+ memcpy((void *)(WritebufferAdd - 4),
+ (void *)(pC->H264MCSTempBuffer), 4);
}
} /* H.264 Trimming */
}
pC->InputFileProperties.Version[2] = M4VIDEOEDITING_VERSION_REVISION;
pC->InputFileProperties.uiClipDuration = 0;
- M4OSA_memset((M4OSA_MemAddr8) &pC->InputFileProperties.ftyp,
- sizeof(M4VIDEOEDITING_FtypBox), 0);
+ memset((void *) &pC->InputFileProperties.ftyp,
+ 0, sizeof(M4VIDEOEDITING_FtypBox));
/**
* Reset video characteristics */
start = pC->ReaderVideoAU.m_dataAddress;
in = pC->WriterVideoAU.dataAddress;
- M4OSA_memset(in, pC->ReaderVideoAU.m_size , 0);
+ memset((void *)in, 0, pC->ReaderVideoAU.m_size);
code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8);
M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, 0, 8);
in++;
is black borders */
if(pC->MediaRendering == M4MCS_kBlackBorders)
{
- M4OSA_memset((M4OSA_MemAddr8)pPlaneOut[0].pac_data,
- (pPlaneOut[0].u_height*pPlaneOut[0].u_stride),
- Y_PLANE_BORDER_VALUE);
- M4OSA_memset((M4OSA_MemAddr8)pPlaneOut[1].pac_data,
- (pPlaneOut[1].u_height*pPlaneOut[1].u_stride),
- U_PLANE_BORDER_VALUE);
- M4OSA_memset((M4OSA_MemAddr8)pPlaneOut[2].pac_data,
- (pPlaneOut[2].u_height*pPlaneOut[2].u_stride),
- V_PLANE_BORDER_VALUE);
+ memset((void *)pPlaneOut[0].pac_data,Y_PLANE_BORDER_VALUE,
+ (pPlaneOut[0].u_height*pPlaneOut[0].u_stride));
+ memset((void *)pPlaneOut[1].pac_data,U_PLANE_BORDER_VALUE,
+ (pPlaneOut[1].u_height*pPlaneOut[1].u_stride));
+ memset((void *)pPlaneOut[2].pac_data,V_PLANE_BORDER_VALUE,
+ (pPlaneOut[2].u_height*pPlaneOut[2].u_stride));
}
else if ((M4OSA_NULL == pC->ReaderVideoAU.m_dataAddress) ||
(M4OSA_NULL == pC->pViDecCtxt))
/**
* We must fill the input of the encoder with a dummy image, because
* encoding noise leads to a huge video AU, and thus a writer buffer overflow. */
- M4OSA_memset((M4OSA_MemAddr8)pPlaneOut[0].pac_data,
- pPlaneOut[0].u_stride * pPlaneOut[0].u_height, 0);
- M4OSA_memset((M4OSA_MemAddr8)pPlaneOut[1].pac_data,
- pPlaneOut[1].u_stride * pPlaneOut[1].u_height, 0);
- M4OSA_memset((M4OSA_MemAddr8)pPlaneOut[2].pac_data,
- pPlaneOut[2].u_stride * pPlaneOut[2].u_height, 0);
+ memset((void *)pPlaneOut[0].pac_data,0,
+ pPlaneOut[0].u_stride * pPlaneOut[0].u_height);
+ memset((void *)pPlaneOut[1].pac_data,0,
+ pPlaneOut[1].u_stride * pPlaneOut[1].u_height);
+ memset((void *)pPlaneOut[2].pac_data,0,
+ pPlaneOut[2].u_stride * pPlaneOut[2].u_height);
M4OSA_TRACE1_0("M4MCS_intApplyVPP: pReaderVideoAU->m_dataAddress is M4OSA_NULL,\
returning M4NO_ERROR");
pInPlaneU = pImagePlanesTemp[1].pac_data ;
pInPlaneV = pImagePlanesTemp[2].pac_data ;
- M4OSA_memset((M4OSA_MemAddr8)pImagePlanesTemp[0].pac_data,
- (pImagePlanesTemp[0].u_height*pImagePlanesTemp[0].u_stride),
- Y_PLANE_BORDER_VALUE);
- M4OSA_memset((M4OSA_MemAddr8)pImagePlanesTemp[1].pac_data,
- (pImagePlanesTemp[1].u_height*pImagePlanesTemp[1].u_stride),
- U_PLANE_BORDER_VALUE);
- M4OSA_memset((M4OSA_MemAddr8)pImagePlanesTemp[2].pac_data,
- (pImagePlanesTemp[2].u_height*pImagePlanesTemp[2].u_stride),
- V_PLANE_BORDER_VALUE);
+ memset((void *)pImagePlanesTemp[0].pac_data,Y_PLANE_BORDER_VALUE,
+ (pImagePlanesTemp[0].u_height*pImagePlanesTemp[0].u_stride));
+ memset((void *)pImagePlanesTemp[1].pac_data,U_PLANE_BORDER_VALUE,
+ (pImagePlanesTemp[1].u_height*pImagePlanesTemp[1].u_stride));
+ memset((void *)pImagePlanesTemp[2].pac_data,V_PLANE_BORDER_VALUE,
+ (pImagePlanesTemp[2].u_height*pImagePlanesTemp[2].u_stride));
if((M4OSA_UInt32)((pC->pPreResizeFrame->u_height * pPlaneOut->u_width)\
/pC->pPreResizeFrame->u_width) <= pPlaneOut->u_height)
{
for(i=0; i<pPlaneOut[0].u_height; i++)
{
- M4OSA_memcpy( (M4OSA_MemAddr8)pOutPlaneY,
- (M4OSA_MemAddr8)pInPlaneY,
+ memcpy( (void *)pOutPlaneY,
+ (void *)pInPlaneY,
pPlaneOut[0].u_width);
pInPlaneY += pPlaneOut[0].u_width;
pOutPlaneY += pPlaneOut[0].u_stride;
}
for(i=0; i<pPlaneOut[1].u_height; i++)
{
- M4OSA_memcpy( (M4OSA_MemAddr8)pOutPlaneU,
- (M4OSA_MemAddr8)pInPlaneU,
+ memcpy( (void *)pOutPlaneU,
+ (void *)pInPlaneU,
pPlaneOut[1].u_width);
pInPlaneU += pPlaneOut[1].u_width;
pOutPlaneU += pPlaneOut[1].u_stride;
}
for(i=0; i<pPlaneOut[2].u_height; i++)
{
- M4OSA_memcpy( (M4OSA_MemAddr8)pOutPlaneV,
- (M4OSA_MemAddr8)pInPlaneV,
+ memcpy( (void *)pOutPlaneV,
+ (void *)pInPlaneV,
pPlaneOut[2].u_width);
pInPlaneV += pPlaneOut[2].u_width;
pOutPlaneV += pPlaneOut[2].u_stride;
else
{
/* Copy last decoded plane to output plane */
- M4OSA_memcpy((M4OSA_MemAddr8)pPlaneOut[0].pac_data,
- (M4OSA_MemAddr8)pC->lastDecodedPlane[0].pac_data,
+ memcpy((void *)pPlaneOut[0].pac_data,
+ (void *)pC->lastDecodedPlane[0].pac_data,
(pPlaneOut[0].u_height * pPlaneOut[0].u_width));
- M4OSA_memcpy((M4OSA_MemAddr8)pPlaneOut[1].pac_data,
- (M4OSA_MemAddr8)pC->lastDecodedPlane[1].pac_data,
+ memcpy((void *)pPlaneOut[1].pac_data,
+ (void *)pC->lastDecodedPlane[1].pac_data,
(pPlaneOut[1].u_height * pPlaneOut[1].u_width));
- M4OSA_memcpy((M4OSA_MemAddr8)pPlaneOut[2].pac_data,
- (M4OSA_MemAddr8)pC->lastDecodedPlane[2].pac_data,
+ memcpy((void *)pPlaneOut[2].pac_data,
+ (void *)pC->lastDecodedPlane[2].pac_data,
(pPlaneOut[2].u_height * pPlaneOut[2].u_width));
pC->lastDecodedPlane = pPlaneOut;
}
}
else
{
- M4OSA_memcpy(pDecodedPCMBuffer->m_dataAddress, pInputBuffer->m_dataAddress,
+ memcpy((void *)pDecodedPCMBuffer->m_dataAddress, (void *)pInputBuffer->m_dataAddress,
pInputBuffer->m_bufferSize );
}
#else /*M4AD_FORCE_16BITS*/
- M4OSA_memcpy(pDecodedPCMBuffer->m_dataAddress, pInputBuffer->m_dataAddress,
+ memcpy((void *)pDecodedPCMBuffer->m_dataAddress, (void *)pInputBuffer->m_dataAddress,
pInputBuffer->m_bufferSize );
#endif /*M4AD_FORCE_16BITS*/
for(j=0;j<pOut[i].u_height;j++)
{
/**< Copy one whole line */
- M4OSA_memcpy((M4OSA_MemAddr8)pu8_data_out, (M4OSA_MemAddr8)pu8_data_in,
+ memcpy((void *)pu8_data_out, (void *)pu8_data_in,
pOut[i].u_width);
/**< Update pointers */
}
/* Fill decoderSpecificInfo structure, with decoder config structure filled in 'openread'
function */
- M4OSA_memcpy((M4OSA_MemAddr8)pStreamDesc->decoderSpecificInfo,
- (M4OSA_MemAddr8)&c->m_decoderConfig, sizeof(M4PCMC_DecoderSpecificInfo));
+ memcpy((void *)pStreamDesc->decoderSpecificInfo,
+ (void *)&c->m_decoderConfig, sizeof(M4PCMC_DecoderSpecificInfo));
/* Fill other fields of pStreamDesc structure */
pStreamDesc->timeScale = 1000;
/**
* Copy the M4PTO3GPP_Params structure */
- M4OSA_memcpy((M4OSA_MemAddr8)(&pC->m_Params),
- (M4OSA_MemAddr8)pParams, sizeof(M4PTO3GPP_Params));
+ memcpy((void *)(&pC->m_Params),
+ (void *)pParams, sizeof(M4PTO3GPP_Params));
M4OSA_TRACE1_1("M4PTO3GPP_Open: outputVideoBitrate = %d", pC->m_Params.OutputVideoBitrate);
/***********************************/
* Copy audio data from reader AU to writer AU */
M4OSA_TRACE2_1("M4PTO3GPP_Step(): Copying audio AU: size=%d",
pC->m_pReaderAudioAU->m_size);
- M4OSA_memcpy((M4OSA_MemAddr8)pC->m_WriterAudioAU.dataAddress,
- (M4OSA_MemAddr8)pC->m_pReaderAudioAU->m_dataAddress,
+ memcpy((void *)pC->m_WriterAudioAU.dataAddress,
+ (void *)pC->m_pReaderAudioAU->m_dataAddress,
pC->m_pReaderAudioAU->m_size);
pC->m_WriterAudioAU.size = pC->m_pReaderAudioAU->m_size;
return err;
}
- M4OSA_memcpy((M4OSA_MemAddr8)pWriterAudioAU->dataAddress,
- (M4OSA_MemAddr8)M4PTO3GPP_AMR_AU_SILENCE_122_FRAME, M4PTO3GPP_AMR_AU_SILENCE_FRAME_122_SIZE);
+ memcpy((void *)pWriterAudioAU->dataAddress,
+ (void *)M4PTO3GPP_AMR_AU_SILENCE_122_FRAME, M4PTO3GPP_AMR_AU_SILENCE_FRAME_122_SIZE);
pWriterAudioAU->size = M4PTO3GPP_AMR_AU_SILENCE_FRAME_122_SIZE;
pWriterAudioAU->CTS = mtIncCts;
pWriterAudioAU->nbFrag = 0;
return err;
}
- M4OSA_memcpy((M4OSA_MemAddr8)pWriterAudioAU->dataAddress,
- (M4OSA_MemAddr8)M4PTO3GPP_AMR_AU_SILENCE_048_FRAME,
+ memcpy((void *)pWriterAudioAU->dataAddress,
+ (void *)M4PTO3GPP_AMR_AU_SILENCE_048_FRAME,
M4PTO3GPP_AMR_AU_SILENCE_FRAME_048_SIZE);
pWriterAudioAU->size = M4PTO3GPP_AMR_AU_SILENCE_FRAME_048_SIZE;
pWriterAudioAU->CTS = mtIncCts;
* (the last pic is splited due to the callback extra-call... */
for (i=0; i<3; i++)
{
- M4OSA_memcpy((M4OSA_MemAddr8)pPlaneOut[i].pac_data,
- (M4OSA_MemAddr8)pC->pSavedPlane[i].pac_data,
+ memcpy((void *)pPlaneOut[i].pac_data,
+ (void *)pC->pSavedPlane[i].pac_data,
pPlaneOut[i].u_stride * pPlaneOut[i].u_height);
}
}
{
if (parsingCtxt->stream_index == 8)
{
- M4OSA_memcpy( (M4OSA_MemAddr8)&(parsingCtxt->stream_byte), parsingCtxt->in,
+ memcpy( (void *)&(parsingCtxt->stream_byte), (void *)parsingCtxt->in,
sizeof(unsigned char));
parsingCtxt->in++;
//fread(&stream_byte, sizeof(unsigned char),1,in);
}
/* Initialization of context Variables */
- M4OSA_memset((M4OSA_MemAddr8)pC ,
- sizeof(M4VSS3GPP_InternalAudioMixingContext),0);
+ memset((void *)pC ,0,
+ sizeof(M4VSS3GPP_InternalAudioMixingContext));
/**
* Copy this setting in context */
pC->iAddCts = pSettings->uiAddCts;
return M4ERR_ALLOC;
}
pC->ewc.uiVideoOutputDsiSize = (M4OSA_UInt16)encHeader->Size;
- M4OSA_memcpy(pC->ewc.pVideoOutputDsi, encHeader->pBuf,
+ memcpy((void *)pC->ewc.pVideoOutputDsi, (void *)encHeader->pBuf,
encHeader->Size);
}
M4OSA_TRACE2_0("A #### silence AU");
- M4OSA_memcpy((M4OSA_MemAddr8)pC->ewc.WriterAudioAU.dataAddress,
- (M4OSA_MemAddr8)pC->ewc.pSilenceFrameData, pC->ewc.uiSilenceFrameSize);
+ memcpy((void *)pC->ewc.WriterAudioAU.dataAddress,
+ (void *)pC->ewc.pSilenceFrameData, pC->ewc.uiSilenceFrameSize);
pC->ewc.WriterAudioAU.size = pC->ewc.uiSilenceFrameSize;
pC->ewc.WriterAudioAU.CTS =
/**
* Copy the input AU payload to the output AU */
- M4OSA_memcpy((M4OSA_MemAddr8)pC->ewc.WriterVideoAU.dataAddress,
- (M4OSA_MemAddr8)(pC->pInputClipCtxt->VideoAU.m_dataAddress + offset),
+ memcpy((void *)pC->ewc.WriterVideoAU.dataAddress,
+ (void *)(pC->pInputClipCtxt->VideoAU.m_dataAddress + offset),
(pC->pInputClipCtxt->VideoAU.m_size));
/**
/**
* Copy the AU itself */
- M4OSA_memcpy((M4OSA_MemAddr8)pC->ewc.WriterAudioAU.dataAddress,
- pC->pInputClipCtxt->pAudioFramePtr, pC->ewc.WriterAudioAU.size);
+ memcpy((void *)pC->ewc.WriterAudioAU.dataAddress,
+ (void *)pC->pInputClipCtxt->pAudioFramePtr, pC->ewc.WriterAudioAU.size);
/**
* Write the mixed AU */
{
tempPosBuffer = pC->pSsrcBufferOut
+ pC->pInputClipCtxt->AudioDecBufferOut.m_bufferSize;
- M4OSA_memmove(pC->pSsrcBufferOut, tempPosBuffer,
+ memmove((void *)pC->pSsrcBufferOut, (void *)tempPosBuffer,
pC->pPosInSsrcBufferOut - tempPosBuffer);
pC->pPosInSsrcBufferOut -=
pC->pInputClipCtxt->AudioDecBufferOut.m_bufferSize;
else
{
tempPosBuffer = pC->pSsrcBufferIn + pC->minimumBufferIn;
- M4OSA_memmove(pC->pSsrcBufferIn, tempPosBuffer,
+ memmove((void *)pC->pSsrcBufferIn, (void *)tempPosBuffer,
pC->pPosInSsrcBufferIn - tempPosBuffer);
pC->pPosInSsrcBufferIn -= pC->minimumBufferIn;
}
/**
* Copy the AU itself */
- M4OSA_memcpy((M4OSA_MemAddr8)pC->ewc.WriterAudioAU.dataAddress,
- pC->pAddedClipCtxt->pAudioFramePtr, pC->ewc.WriterAudioAU.size);
+ memcpy((void *)pC->ewc.WriterAudioAU.dataAddress,
+ (void *)pC->pAddedClipCtxt->pAudioFramePtr, pC->ewc.WriterAudioAU.size);
/**
* Write the mixed AU */
}
/* Copy decoded data into SSRC buffer in */
- M4OSA_memcpy(pC->pPosInSsrcBufferIn,
- pC->pAddedClipCtxt->AudioDecBufferOut.m_dataAddress,
+ memcpy((void *)pC->pPosInSsrcBufferIn,
+ (void *)pC->pAddedClipCtxt->AudioDecBufferOut.m_dataAddress,
pC->pAddedClipCtxt->AudioDecBufferOut.m_bufferSize);
/* Update position pointer into SSRC buffer In */
/* We use ChannelConversion variable because in case 2, we need twice less data */
{
ssrcErr = 0;
- M4OSA_memset(pC->pPosInTempBuffer,
- (pC->iSsrcNbSamplOut * sizeof(short) * pC->ewc.uiNbChannels),0);
+ memset((void *)pC->pPosInTempBuffer,0,
+ (pC->iSsrcNbSamplOut * sizeof(short) * pC->ewc.uiNbChannels));
LVAudioresample_LowQuality((short*)pC->pPosInTempBuffer,
(short*)pC->pSsrcBufferIn,
pC->pSsrcBufferIn + (pC->iSsrcNbSamplIn * sizeof(short)
* pC->pAddedClipCtxt->pSettings->
ClipProperties.uiNbChannels);
- M4OSA_memmove(pC->pSsrcBufferIn, tempPosBuffer,
+ memmove((void *)pC->pSsrcBufferIn, (void *)tempPosBuffer,
pC->pPosInSsrcBufferIn - tempPosBuffer);
pC->pPosInSsrcBufferIn -= pC->iSsrcNbSamplIn * sizeof(short)
* pC->pAddedClipCtxt->pSettings->
< (M4OSA_Int32)pC->pInputClipCtxt->AudioDecBufferOut.m_bufferSize )
{
ssrcErr = 0;
- M4OSA_memset(pC->pPosInSsrcBufferOut,
- (pC->iSsrcNbSamplOut * sizeof(short) * pC->ewc.uiNbChannels),0);
+ memset((void *)pC->pPosInSsrcBufferOut,0,
+ (pC->iSsrcNbSamplOut * sizeof(short) * pC->ewc.uiNbChannels));
LVAudioresample_LowQuality((short*)pC->pPosInSsrcBufferOut,
(short*)pC->pSsrcBufferIn,
pC->pSsrcBufferIn + (pC->iSsrcNbSamplIn * sizeof(short)
* pC->pAddedClipCtxt->pSettings->
ClipProperties.uiNbChannels);
- M4OSA_memmove(pC->pSsrcBufferIn, tempPosBuffer,
+ memmove((void *)pC->pSsrcBufferIn, (void *)tempPosBuffer,
pC->pPosInSsrcBufferIn - tempPosBuffer);
pC->pPosInSsrcBufferIn -= pC->iSsrcNbSamplIn * sizeof(short)
* pC->pAddedClipCtxt->pSettings->
* pC->pAddedClipCtxt->pSettings->
ClipProperties.
uiNbChannels); /* Buffer is in bytes */
- M4OSA_memmove(pC->pTempBuffer, tempPosBuffer,
+ memmove((void *)pC->pTempBuffer, (void *)tempPosBuffer,
pC->pPosInTempBuffer - tempPosBuffer);
pC->pPosInTempBuffer -=
(uiChannelConvertorNbSamples * sizeof(short)
+ (uiChannelConvertorNbSamples * sizeof(short)
* pC->pAddedClipCtxt->pSettings->
ClipProperties.uiNbChannels);
- M4OSA_memmove(pC->pTempBuffer, tempPosBuffer,
+ memmove((void *)pC->pTempBuffer, (void *)tempPosBuffer,
pC->pPosInTempBuffer - tempPosBuffer);
pC->pPosInTempBuffer -=
(uiChannelConvertorNbSamples * sizeof(short)
* pC->pAddedClipCtxt->pSettings->
ClipProperties.
uiNbChannels); /* Buffer is in bytes */
- M4OSA_memmove(pC->pSsrcBufferIn, tempPosBuffer,
+ memmove((void *)pC->pSsrcBufferIn, (void *)tempPosBuffer,
pC->pPosInSsrcBufferIn - tempPosBuffer);
pC->pPosInSsrcBufferIn -=
(uiChannelConvertorNbSamples * sizeof(short)
+ (uiChannelConvertorNbSamples * sizeof(short)
* pC->pAddedClipCtxt->pSettings->
ClipProperties.uiNbChannels);
- M4OSA_memmove(pC->pSsrcBufferIn, tempPosBuffer,
+ memmove((void *)pC->pSsrcBufferIn, (void *)tempPosBuffer,
pC->pPosInSsrcBufferIn - tempPosBuffer);
pC->pPosInSsrcBufferIn -=
(uiChannelConvertorNbSamples * sizeof(short)
{
tempPosBuffer = pC->pSsrcBufferOut
+ pC->pInputClipCtxt->AudioDecBufferOut.m_bufferSize;
- M4OSA_memmove(pC->pSsrcBufferOut, tempPosBuffer,
+ memmove((void *)pC->pSsrcBufferOut, (void *)tempPosBuffer,
pC->pPosInSsrcBufferOut - tempPosBuffer);
pC->pPosInSsrcBufferOut -=
pC->pInputClipCtxt->AudioDecBufferOut.m_bufferSize;
{
tempPosBuffer = pC->pSsrcBufferIn
+ pC->pInputClipCtxt->AudioDecBufferOut.m_bufferSize;
- M4OSA_memmove(pC->pSsrcBufferIn, tempPosBuffer,
+ memmove((void *)pC->pSsrcBufferIn, (void *)tempPosBuffer,
pC->pPosInSsrcBufferIn - tempPosBuffer);
pC->pPosInSsrcBufferIn -=
pC->pInputClipCtxt->AudioDecBufferOut.m_bufferSize;
pClipCtxt = *hClipCtxt;
/* Inialization of context Variables */
- M4OSA_memset((M4OSA_MemAddr8)pClipCtxt, sizeof(M4VSS3GPP_ClipContext), 0);
+ memset((void *)pClipCtxt, 0,sizeof(M4VSS3GPP_ClipContext));
pClipCtxt->pSettings = M4OSA_NULL;
}
/* Fill it with 0 (= pcm silence) */
- M4OSA_memset(pClipCtxt->AudioDecBufferOut.m_dataAddress,
- pClipCtxt->AudioDecBufferOut.m_bufferSize * sizeof(M4OSA_Int16), 0);
+ memset(pClipCtxt->AudioDecBufferOut.m_dataAddress,0,
+ pClipCtxt->AudioDecBufferOut.m_bufferSize * sizeof(M4OSA_Int16));
}
else if (pClipCtxt->pSettings->FileType == M4VIDEOEDITING_kFileType_PCM)
{
pClipCtxt->AudioDecBufferIn.m_dataAddress = (M4OSA_MemAddr8) pClipCtxt->pAudioFramePtr;
pClipCtxt->AudioDecBufferIn.m_bufferSize = pClipCtxt->uiAudioFrameSize;
- M4OSA_memcpy(pClipCtxt->AudioDecBufferOut.m_dataAddress,
- pClipCtxt->AudioDecBufferIn.m_dataAddress, pClipCtxt->AudioDecBufferIn.m_bufferSize);
+ memcpy((void *)pClipCtxt->AudioDecBufferOut.m_dataAddress,
+ (void *)pClipCtxt->AudioDecBufferIn.m_dataAddress, pClipCtxt->AudioDecBufferIn.m_bufferSize);
pClipCtxt->AudioDecBufferOut.m_bufferSize = pClipCtxt->AudioDecBufferIn.m_bufferSize;
/**
* Return with no error */
pClipProperties->bMPEG4rvlc = M4OSA_FALSE;
pClipProperties->bMPEG4resynchMarker = M4OSA_FALSE;
- M4OSA_memset((M4OSA_MemAddr8) &pClipProperties->ftyp,
- sizeof(pClipProperties->ftyp), 0);
+ memset((void *) &pClipProperties->ftyp,0,
+ sizeof(pClipProperties->ftyp));
/**
* Video Analysis */
M4VSS3GPP, (M4OSA_Char *)"M4VSS3GPP_InternalContext");
*pContext = pC;
/* Inialization of context Variables */
- M4OSA_memset((M4OSA_MemAddr8)pC, sizeof(M4VSS3GPP_InternalEditContext), 0);
+ memset((void *)pC, 0,sizeof(M4VSS3GPP_InternalEditContext));
if( M4OSA_NULL == pC )
{
if( M4OSA_NULL != pFile )
{
- //pClipSettings->pFile = (M4OSA_Char*) M4OSA_malloc(M4OSA_chrLength(pFile)+1, M4VSS3GPP,
+ //pClipSettings->pFile = (M4OSA_Char*) M4OSA_malloc(strlen(pFile)+1, M4VSS3GPP,
// "pClipSettings->pFile");
/*FB: add clip path size because of utf 16 conversion*/
pClipSettings->pFile =
"M4VSS3GPP_editCreateClipSettings : ERROR allocating filename");
return M4ERR_ALLOC;
}
- //M4OSA_memcpy(pClipSettings->pFile, pFile, M4OSA_chrLength(pFile)+1);
+ //memcpy(pClipSettings->pFile, pFile, strlen(pFile)+1);
/*FB: add clip path size because of utf 16 conversion*/
- M4OSA_memcpy(pClipSettings->pFile, pFile, filePathSize + 1);
+ memcpy((void *)pClipSettings->pFile, (void *)pFile, filePathSize + 1);
}
/*FB: add file path size to support UTF16 conversion*/
"M4VSS3GPP_editDuplicateClipSettings: pClipSettingsOrig is NULL");
/* Copy plain structure */
- M4OSA_memcpy((M4OSA_MemAddr8)pClipSettingsDest,
- (M4OSA_MemAddr8)pClipSettingsOrig, sizeof(M4VSS3GPP_ClipSettings));
+ memcpy((void *)pClipSettingsDest,
+ (void *)pClipSettingsOrig, sizeof(M4VSS3GPP_ClipSettings));
/* Duplicate filename */
if( M4OSA_NULL != pClipSettingsOrig->pFile )
{
//pClipSettingsDest->pFile =
- // (M4OSA_Char*) M4OSA_malloc(M4OSA_chrLength(pClipSettingsOrig->pFile)+1, M4VSS3GPP,
+ // (M4OSA_Char*) M4OSA_malloc(strlen(pClipSettingsOrig->pFile)+1, M4VSS3GPP,
// "pClipSettingsDest->pFile");
/*FB: clip path size is needed for utf 16 conversion*/
/*FB 2008/10/16: bad allocation size which raises a crash*/
return M4ERR_ALLOC;
}
/*FB: clip path size is needed for utf 16 conversion*/
- //M4OSA_memcpy(pClipSettingsDest->pFile, pClipSettingsOrig->pFile,
- // M4OSA_chrLength(pClipSettingsOrig->pFile)+1);
+ //memcpy(pClipSettingsDest->pFile, pClipSettingsOrig->pFile,
+ // strlen(pClipSettingsOrig->pFile)+1);
/*FB 2008/10/16: bad allocation size which raises a crash*/
- M4OSA_memcpy(pClipSettingsDest->pFile, pClipSettingsOrig->pFile,
+ memcpy((void *)pClipSettingsDest->pFile, (void *)pClipSettingsOrig->pFile,
pClipSettingsOrig->filePathSize/*+1*/);
( (M4OSA_Char
*)pClipSettingsDest->pFile)[pClipSettingsOrig->filePathSize] = '\0';
for ( uiFx = 0; uiFx < pClipSettingsOrig->nbEffects; uiFx++ )
{
/* Copy plain structure */
- M4OSA_memcpy(
- (M4OSA_MemAddr8) &(pClipSettingsDest->Effects[uiFx]),
- (M4OSA_MemAddr8) &(pClipSettingsOrig->Effects[uiFx]),
+ memcpy(
+ (void *) &(pClipSettingsDest->Effects[uiFx]),
+ (void *) &(pClipSettingsOrig->Effects[uiFx]),
sizeof(M4VSS3GPP_EffectSettings));
}
}
for ( i = 0; i < pC->nbEffects; i++ )
{
- M4OSA_memcpy((M4OSA_MemAddr8) &(pC->pEffectsList[i]),
- (M4OSA_MemAddr8) &(pSettings->Effects[i]),
+ memcpy((void *) &(pC->pEffectsList[i]),
+ (void *) &(pSettings->Effects[i]),
sizeof(M4VSS3GPP_EffectSettings));
}
/**< copy transition settings */
for ( i = 0; i < (pSettings->uiClipNumber - 1); i++ )
{
- M4OSA_memcpy((M4OSA_MemAddr8) &(pC->pTransitionList[i]),
- (M4OSA_MemAddr8)pSettings->pTransitionList[i],
+ memcpy((void *) &(pC->pTransitionList[i]),
+ (void *)pSettings->pTransitionList[i],
sizeof(M4VSS3GPP_TransitionSettings));
}
}
pC->ewc.uiVideoOutputDsiSize =
(M4OSA_UInt16)pStreamForDsi->m_decoderSpecificInfoSize;
- M4OSA_memcpy(pC->ewc.pVideoOutputDsi,
- (M4OSA_MemAddr8)pStreamForDsi->m_pDecoderSpecificInfo,
+ memcpy((void *)pC->ewc.pVideoOutputDsi,
+ (void *)pStreamForDsi->m_pDecoderSpecificInfo,
pC->ewc.uiVideoOutputDsiSize);
/**
return M4ERR_ALLOC;
}
pC->ewc.uiVideoOutputDsiSize = (M4OSA_UInt16)encHeader->Size;
- M4OSA_memcpy(pC->ewc.pVideoOutputDsi, encHeader->pBuf,
+ memcpy((void *)pC->ewc.pVideoOutputDsi, (void *)encHeader->pBuf,
encHeader->Size);
}
}
pC->ewc.uiAudioOutputDsiSize =
(M4OSA_UInt16)pStreamForDsi->m_decoderSpecificInfoSize;
- M4OSA_memcpy(pC->ewc.pAudioOutputDsi,
- (M4OSA_MemAddr8)pStreamForDsi->m_pDecoderSpecificInfo,
+ memcpy((void *)pC->ewc.pAudioOutputDsi,
+ (void *)pStreamForDsi->m_pDecoderSpecificInfo,
pC->ewc.uiAudioOutputDsiSize);
/**
/**
* Copy a silence AU to the output */
pC->ewc.WriterAudioAU.size = pC->ewc.uiSilenceFrameSize;
- M4OSA_memcpy((M4OSA_MemAddr8)pC->ewc.WriterAudioAU.dataAddress,
- (M4OSA_MemAddr8)pC->ewc.pSilenceFrameData, pC->ewc.uiSilenceFrameSize);
+ memcpy((void *)pC->ewc.WriterAudioAU.dataAddress,
+ (void *)pC->ewc.pSilenceFrameData, pC->ewc.uiSilenceFrameSize);
M4OSA_TRACE2_0("A #### silence AU");
}
else if( (M4OSA_UInt32)pC->pC1->uiAudioFrameSize
* Copy the input AU to the output AU */
pC->ewc.WriterAudioAU.size =
(M4OSA_UInt32)pC->pC1->uiAudioFrameSize;
- M4OSA_memcpy((M4OSA_MemAddr8)pC->ewc.WriterAudioAU.dataAddress,
- pC->pC1->pAudioFramePtr, pC->ewc.WriterAudioAU.size);
+ memcpy((void *)pC->ewc.WriterAudioAU.dataAddress,
+ (void *)pC->pC1->pAudioFramePtr, pC->ewc.WriterAudioAU.size);
}
else
{
/**
* Copy a silence AMR AU to the output */
pC->ewc.WriterAudioAU.size = pC->ewc.uiSilenceFrameSize;
- M4OSA_memcpy((M4OSA_MemAddr8)pC->ewc.WriterAudioAU.dataAddress,
- (M4OSA_MemAddr8)pC->ewc.pSilenceFrameData, pC->ewc.uiSilenceFrameSize);
+ memcpy((void *)pC->ewc.WriterAudioAU.dataAddress,
+ (void *)pC->ewc.pSilenceFrameData, pC->ewc.uiSilenceFrameSize);
M4OSA_TRACE2_0("G #### silence AU");
}
else
{
/**
* Copy the input PCM to the output buffer */
- M4OSA_memcpy((M4OSA_MemAddr8)pPCMdata1,
- (M4OSA_MemAddr8)pPCMdata2, uiPCMsize);
+ memcpy((void *)pPCMdata1,
+ (void *)pPCMdata2, uiPCMsize);
}
/**
* the output must be put in the first buffer.
return M4VSS3GPP_ERR_INPUT_VIDEO_AU_TOO_LARGE;
}
- M4OSA_memcpy((M4OSA_MemAddr8)pC->ewc.WriterVideoAU.dataAddress,
- (pC->pC1->VideoAU.m_dataAddress + offset),
+ memcpy((void *)pC->ewc.WriterVideoAU.dataAddress,
+ (void *)(pC->pC1->VideoAU.m_dataAddress + offset),
(pC->ewc.WriterVideoAU.size));
/**
/**
* We must fill the input of the encoder with a dummy image, because
* encoding noise leads to a huge video AU, and thus a writer buffer overflow. */
- M4OSA_memset((M4OSA_MemAddr8)pPlaneOut[0].pac_data,
- pPlaneOut[0].u_stride * pPlaneOut[0].u_height, 0);
- M4OSA_memset((M4OSA_MemAddr8)pPlaneOut[1].pac_data,
- pPlaneOut[1].u_stride * pPlaneOut[1].u_height, 0);
- M4OSA_memset((M4OSA_MemAddr8)pPlaneOut[2].pac_data,
- pPlaneOut[2].u_stride * pPlaneOut[2].u_height, 0);
+ memset((void *)pPlaneOut[0].pac_data,0,
+ pPlaneOut[0].u_stride * pPlaneOut[0].u_height);
+ memset((void *)pPlaneOut[1].pac_data,0,
+ pPlaneOut[1].u_stride * pPlaneOut[1].u_height);
+ memset((void *)pPlaneOut[2].pac_data,0,
+ pPlaneOut[2].u_stride * pPlaneOut[2].u_height);
M4OSA_TRACE3_0("M4VSS3GPP_intVPP: returning M4NO_ERROR (abort)");
return M4NO_ERROR;
else
{
/* Copy last decoded plane to output plane */
- M4OSA_memcpy((M4OSA_MemAddr8)pTmp[0].pac_data,
- (M4OSA_MemAddr8)pC->pC1->lastDecodedPlane[0].pac_data,
+ memcpy((void *)pTmp[0].pac_data,
+ (void *)pC->pC1->lastDecodedPlane[0].pac_data,
(pTmp[0].u_height * pTmp[0].u_width));
- M4OSA_memcpy((M4OSA_MemAddr8)pTmp[1].pac_data,
- (M4OSA_MemAddr8)pC->pC1->lastDecodedPlane[1].pac_data,
+ memcpy((void *)pTmp[1].pac_data,
+ (void *)pC->pC1->lastDecodedPlane[1].pac_data,
(pTmp[1].u_height * pTmp[1].u_width));
- M4OSA_memcpy((M4OSA_MemAddr8)pTmp[2].pac_data,
- (M4OSA_MemAddr8)pC->pC1->lastDecodedPlane[2].pac_data,
+ memcpy((void *)pTmp[2].pac_data,
+ (void *)pC->pC1->lastDecodedPlane[2].pac_data,
(pTmp[2].u_height * pTmp[2].u_width));
pC->pC1->lastDecodedPlane = pTmp;
}
else
{
/* Copy last decoded plane to output plane */
- M4OSA_memcpy((M4OSA_MemAddr8)pTmp[0].pac_data,
- (M4OSA_MemAddr8)pC->pC2->lastDecodedPlane[0].pac_data,
+ memcpy((void *)pTmp[0].pac_data,
+ (void *)pC->pC2->lastDecodedPlane[0].pac_data,
(pTmp[0].u_height * pTmp[0].u_width));
- M4OSA_memcpy((M4OSA_MemAddr8)pTmp[1].pac_data,
- (M4OSA_MemAddr8)pC->pC2->lastDecodedPlane[1].pac_data,
+ memcpy((void *)pTmp[1].pac_data,
+ (void *)pC->pC2->lastDecodedPlane[1].pac_data,
(pTmp[1].u_height * pTmp[1].u_width));
- M4OSA_memcpy((M4OSA_MemAddr8)pTmp[2].pac_data,
- (M4OSA_MemAddr8)pC->pC2->lastDecodedPlane[2].pac_data,
+ memcpy((void *)pTmp[2].pac_data,
+ (void *)pC->pC2->lastDecodedPlane[2].pac_data,
(pTmp[2].u_height * pTmp[2].u_width));
pC->pC2->lastDecodedPlane = pTmp;
}
else
{
/* Copy last decoded plane to output plane */
- M4OSA_memcpy((M4OSA_MemAddr8)pTmp[0].pac_data,
- (M4OSA_MemAddr8)pC->pC1->lastDecodedPlane[0].pac_data,
+ memcpy((void *)pTmp[0].pac_data,
+ (void *)pC->pC1->lastDecodedPlane[0].pac_data,
(pTmp[0].u_height * pTmp[0].u_width));
- M4OSA_memcpy((M4OSA_MemAddr8)pTmp[1].pac_data,
- (M4OSA_MemAddr8)pC->pC1->lastDecodedPlane[1].pac_data,
+ memcpy((void *)pTmp[1].pac_data,
+ (void *)pC->pC1->lastDecodedPlane[1].pac_data,
(pTmp[1].u_height * pTmp[1].u_width));
- M4OSA_memcpy((M4OSA_MemAddr8)pTmp[2].pac_data,
- (M4OSA_MemAddr8)pC->pC1->lastDecodedPlane[2].pac_data,
+ memcpy((void *)pTmp[2].pac_data,
+ (void *)pC->pC1->lastDecodedPlane[2].pac_data,
(pTmp[2].u_height * pTmp[2].u_width));
pC->pC1->lastDecodedPlane = pTmp;
}
while( i-- > 0 )
{
- M4OSA_memcpy((M4OSA_MemAddr8)pPlaneOut[i].pac_data,
- (M4OSA_MemAddr8)pPlane[i].pac_data,
+ memcpy((void *)pPlaneOut[i].pac_data,
+ (void *)pPlane[i].pac_data,
pPlaneOut[i].u_stride * pPlaneOut[i].u_height);
}
break;
M4OSA_TRACE1_0("Allocation error in M4xVSS_Init");
return M4ERR_ALLOC;
}
- M4OSA_memcpy(xVSS_context->pTempPath, pParams->pTempPath,
+ memcpy((void *)xVSS_context->pTempPath, (void *)pParams->pTempPath,
strlen(pParams->pTempPath) + 1);
/* TODO: Check that no previous xVSS temporary files are present ? */
}
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy((M4OSA_MemAddr8)xVSS_context->pSettings->pOutputFile,
- (M4OSA_MemAddr8)pDecodedPath, pSettings->uiOutputPathSize + 1);
+ memcpy((void *)xVSS_context->pSettings->pOutputFile,
+ (void *)pDecodedPath, pSettings->uiOutputPathSize + 1);
xVSS_context->pSettings->uiOutputPathSize = pSettings->uiOutputPathSize;
xVSS_context->pOutputFile = xVSS_context->pSettings->pOutputFile;
}
return M4ERR_ALLOC;
}
/* Set clip list to NULL */
- M4OSA_memset((M4OSA_MemAddr8)xVSS_context->pSettings->pClipList,
+ memset((void *)xVSS_context->pSettings->pClipList,0,
sizeof(M4VSS3GPP_ClipSettings *)
- *xVSS_context->pSettings->uiClipNumber, 0);
+ *xVSS_context->pSettings->uiClipNumber);
if( xVSS_context->pSettings->uiClipNumber > 1 )
{
return M4ERR_ALLOC;
}
/* Set transition list to NULL */
- M4OSA_memset(
- (M4OSA_MemAddr8)xVSS_context->pSettings->pTransitionList,
+ memset(
+ (void *)xVSS_context->pSettings->pTransitionList,0,
sizeof(M4VSS3GPP_TransitionSettings *)
- *(xVSS_context->pSettings->uiClipNumber - 1), 0);
+ *(xVSS_context->pSettings->uiClipNumber - 1));
}
else
{
return M4ERR_ALLOC;
}
- M4OSA_memcpy(
- (M4OSA_MemAddr8)xVSS_context->pSettings->pTransitionList[i],
- (M4OSA_MemAddr8)pSettings->pTransitionList[i],
+ memcpy(
+ (void *)xVSS_context->pSettings->pTransitionList[i],
+ (void *)pSettings->pTransitionList[i],
sizeof(M4VSS3GPP_TransitionSettings));
/* Initialize external effect context to NULL, to know if input jpg has already been
decoded or not */
}
/* Copy data from the provided alpha magic settings structure tou our
structure */
- M4OSA_memcpy((M4OSA_MemAddr8)xVSS_context->pSettings->
+ memcpy((void *)xVSS_context->pSettings->
pTransitionList[i]-> \
xVSS.transitionSpecific.pAlphaMagicSettings,
- (M4OSA_MemAddr8)pSettings->pTransitionList[i]-> \
+ (void *)pSettings->pTransitionList[i]-> \
xVSS.transitionSpecific.pAlphaMagicSettings,
sizeof(M4xVSS_AlphaMagicSettings));
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy(pParams->pFileIn, pDecodedPath,
+ memcpy((void *)pParams->pFileIn, (void *)pDecodedPath,
(length + 1)); /* Copy input file path */
/* Check that JPG file is present on the FS (P4ME00002974) by just opening and
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy(pParams->pFileOut, pDecodedPath,
+ memcpy((void *)pParams->pFileOut, (void *)pDecodedPath,
(length + 1)); /* Copy output file path */
#ifdef M4xVSS_RESERVED_MOOV_DISK_SPACE
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy(pParams->pFileTemp, pDecodedPath,
+ memcpy((void *)pParams->pFileTemp, (void *)pDecodedPath,
(length + 1)); /* Copy temporary file path */
#endif /*M4xVSS_RESERVED_MOOV_DISK_SPACE*/
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy(xVSS_context->pSettings->pClipList[i]->pFile,
- pDecodedPath, (length + 1));
+ memcpy((void *)xVSS_context->pSettings->pClipList[i]->pFile,
+ (void *)pDecodedPath, (length + 1));
/*FB: add file path size because of UTF16 conversion*/
xVSS_context->pSettings->pClipList[i]->filePathSize = length+1;
}
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy(pParams->pFileIn, pDecodedPath,
+ memcpy((void *)pParams->pFileIn, (void *)pDecodedPath,
(length + 1)); /* Copy input file path */
/* Check that JPG file is present on the FS (P4ME00002974) by just opening
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy(pParams->pFileOut, pDecodedPath,
+ memcpy((void *)pParams->pFileOut, (void *)pDecodedPath,
(length + 1)); /* Copy output file path */
#ifdef M4xVSS_RESERVED_MOOV_DISK_SPACE
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy(pParams->pFileTemp, pDecodedPath,
+ memcpy((void *)pParams->pFileTemp, (void *)pDecodedPath,
(length + 1)); /* Copy temporary file path */
#endif /*M4xVSS_RESERVED_MOOV_DISK_SPACE*/
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy(xVSS_context->pSettings->pClipList[i]->pFile,
- pDecodedPath, (length + 1));
+ memcpy((void *)xVSS_context->pSettings->pClipList[i]->pFile,
+ (void *)pDecodedPath, (length + 1));
/*FB: add file path size because of UTF16 conversion*/
xVSS_context->pSettings->pClipList[i]->filePathSize = length+1;
}
/* Initialize file properties structure */
- M4OSA_memset((M4OSA_MemAddr8) &fileProperties,
- sizeof(M4VIDEOEDITING_ClipProperties), 0);
+ memset((void *) &fileProperties,0,
+ sizeof(M4VIDEOEDITING_ClipProperties));
//fileProperties.AudioStreamType = M4VIDEOEDITING_kNoneAudio;
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy(pParams->pFileIn, pDecodedPath,
+ memcpy((void *)pParams->pFileIn, (void *)pDecodedPath,
(length + 1)); /* Copy input file path */
/**
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy(pParams->pFileOut, pDecodedPath,
+ memcpy((void *)pParams->pFileOut, (void *)pDecodedPath,
(length + 1)); /* Copy output file path */
#ifdef M4xVSS_RESERVED_MOOV_DISK_SPACE
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy(pParams->pFileTemp, pDecodedPath,
+ memcpy((void *)pParams->pFileTemp, (void *)pDecodedPath,
(length + 1)); /* Copy temporary file path */
#else
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy(xVSS_context->pSettings->pClipList[i]->pFile,
- pDecodedPath, (length + 1));
+ memcpy((void *)xVSS_context->pSettings->pClipList[i]->pFile,
+ (void *)pDecodedPath, (length + 1));
/*FB: add file path size because of UTF 16 conversion*/
xVSS_context->pSettings->pClipList[i]->filePathSize = length+1;
for ( j = 0; j < xVSS_context->pSettings->nbEffects; j++ )
{
/* Copy effect to "local" structure */
- M4OSA_memcpy((M4OSA_MemAddr8) &(xVSS_context->pSettings->Effects[j]),
- (M4OSA_MemAddr8) &(pSettings->Effects[j]),
+ memcpy((void *) &(xVSS_context->pSettings->Effects[j]),
+ (void *) &(pSettings->Effects[j]),
sizeof(M4VSS3GPP_EffectSettings));
/* Prevent from bad initializing of effect percentage time */
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy((M4OSA_MemAddr8)xVSS_context->pSettings->
+ memcpy((void *)xVSS_context->pSettings->
Effects[j].xVSS.pFramingFilePath,
- (M4OSA_MemAddr8)pSettings->
+ (void *)pSettings->
Effects[j].xVSS.pFramingFilePath, strlen(
pSettings->Effects[j].xVSS.pFramingFilePath) + 1);
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy((M4OSA_MemAddr8)framingCtx->pEffectFilePath,
- (M4OSA_MemAddr8)pDecodedPath, length + 1);
+ memcpy((void *)framingCtx->pEffectFilePath,
+ (void *)pDecodedPath, length + 1);
/* Save framing structure associated with corresponding effect */
xVSS_context->pSettings->Effects[j].pExtVideoEffectFctCtxt =
M4VS, (M4OSA_Char *)"Local text buffer effect");
//xVSS_context->pSettings->Effects[j].xVSS.pTextBuffer =
- // M4OSA_malloc(M4OSA_chrLength(pSettings->Effects[j].xVSS.pTextBuffer)+1,
+ // M4OSA_malloc(strlen(pSettings->Effects[j].xVSS.pTextBuffer)+1,
// M4VS, "Local text buffer effect");
if( xVSS_context->pSettings->Effects[j].xVSS.pTextBuffer
== M4OSA_NULL )
if( pSettings->Effects[j].xVSS.pTextBuffer != M4OSA_NULL )
{
- //M4OSA_memcpy((M4OSA_MemAddr8)xVSS_context->pSettings->Effects[j]
+ //memcpy((M4OSA_MemAddr8)xVSS_context->pSettings->Effects[j]
//.xVSS.pTextBuffer, (M4OSA_MemAddr8)pSettings->Effects[j].xVSS.pTextBuffer,
- // M4OSA_chrLength(pSettings->Effects[j].xVSS.pTextBuffer)+1);
- M4OSA_memcpy((M4OSA_MemAddr8)xVSS_context->pSettings->
+ // strlen(pSettings->Effects[j].xVSS.pTextBuffer)+1);
+ memcpy((void *)xVSS_context->pSettings->
Effects[j].xVSS.pTextBuffer,
- (M4OSA_MemAddr8)pDecodedPath, xVSS_context->pSettings->
+ (void *)pDecodedPath, xVSS_context->pSettings->
Effects[j].xVSS.textBufferSize + 1);
}
}
/* Copy input structure to our structure */
- M4OSA_memcpy((M4OSA_MemAddr8)xVSS_context->pSettings->xVSS.pBGMtrack,
- (M4OSA_MemAddr8)pSettings->xVSS.pBGMtrack,
+ memcpy((void *)xVSS_context->pSettings->xVSS.pBGMtrack,
+ (void *)pSettings->xVSS.pBGMtrack,
sizeof(M4xVSS_BGMSettings));
/* Allocate file name, and copy file name buffer to our structure */
xVSS_context->pSettings->xVSS.pBGMtrack->pFile =
M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
return M4ERR_ALLOC;
}
- M4OSA_memcpy(xVSS_context->pSettings->xVSS.pBGMtrack->pFile,
+ memcpy((void *)xVSS_context->pSettings->xVSS.pBGMtrack->pFile,
(void *)pSettings->xVSS.pBGMtrack->pFile,
strlen(pSettings->xVSS.pBGMtrack->pFile) + 1);
/**/
return M4ERR_ALLOC;
}
- M4OSA_memcpy(xVSS_context->pcmPreviewFile, pDecodedPath, length + 1);
+ memcpy((void *)xVSS_context->pcmPreviewFile, (void *)pDecodedPath, length + 1);
/* Free temporary output filename */
if( out_pcm != M4OSA_NULL )
}
pParams->pFileTemp = M4OSA_NULL;
- M4OSA_memcpy(pParams->pFileOut, xVSS_context->pcmPreviewFile,
+ memcpy((void *)pParams->pFileOut,(void *) xVSS_context->pcmPreviewFile,
(length + 1)); /* Copy output file path */
#if 0
M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
return M4ERR_ALLOC;
}
- M4OSA_memcpy(pParams->pFileIn, pDecodedPath,
+ memcpy((void *)pParams->pFileIn, (void *)pDecodedPath,
(length + 1)); /* Copy input file path */
pParams->isBGM = M4OSA_TRUE;
M4OSA_TRACE1_0("Allocation error in M4xVSS_SaveStart");
return M4ERR_ALLOC;
}
- M4OSA_memcpy(xVSS_context->pOutputFile, pDecodedPath, filePathSize + 1);
+ memcpy((void *)xVSS_context->pOutputFile, (void *)pDecodedPath, filePathSize + 1);
xVSS_context->pOutputFile[filePathSize] = '\0';
xVSS_context->pSettings->pOutputFile = xVSS_context->pOutputFile;
xVSS_context->pSettings->uiOutputPathSize = filePathSize;
}
/* Copy settings from input structure */
- M4OSA_memcpy((M4OSA_MemAddr8) &(pEditSavingSettings->xVSS),
- (M4OSA_MemAddr8) &(xVSS_context->pSettings->xVSS),
+ memcpy((void *) &(pEditSavingSettings->xVSS),
+ (void *) &(xVSS_context->pSettings->xVSS),
sizeof(M4xVSS_EditSettings));
/* Initialize pEditSavingSettings structure */
}
return M4ERR_ALLOC;
}
- M4OSA_memcpy(pEditSavingSettings->pClipList[i]->pFile,
- pDecodedPath, length + 1);
+ memcpy((void *)pEditSavingSettings->pClipList[i]->pFile,
+ (void *)pDecodedPath, length + 1);
}
/*FB: add file path size because of UTF 16 conversion*/
pEditSavingSettings->pClipList[i]->filePathSize = length+1;
< xVSS_context->pSettings->uiClipNumber
- 1 ) /* Because there is 1 less transition than clip number */
{
- M4OSA_memcpy(
- (M4OSA_MemAddr8)pEditSavingSettings->pTransitionList[i],
- (M4OSA_MemAddr8)xVSS_context->pSettings->
+ memcpy(
+ (void *)pEditSavingSettings->pTransitionList[i],
+ (void *)xVSS_context->pSettings->
pTransitionList[i],
sizeof(M4VSS3GPP_TransitionSettings));
}
/* Just copy effect structure to saving structure, as effects time are now */
/* relative to output clip time*/
- M4OSA_memcpy((M4OSA_MemAddr8)pEditSavingSettings->Effects,
- (M4OSA_MemAddr8)xVSS_context->pSettings->Effects,
+ memcpy((void *)pEditSavingSettings->Effects,
+ (void *)xVSS_context->pSettings->Effects,
nbEffects * sizeof(M4VSS3GPP_EffectSettings));
}
else
/* Just copy effect structure to saving structure, as effects time are now */
/* relative to output clip time*/
- M4OSA_memcpy((M4OSA_MemAddr8)pEditSavingSettings->xVSS.pBGMtrack,
- (M4OSA_MemAddr8)xVSS_context->pSettings->xVSS.pBGMtrack,
+ memcpy((void *)pEditSavingSettings->xVSS.pBGMtrack,
+ (void *)xVSS_context->pSettings->xVSS.pBGMtrack,
sizeof(M4xVSS_BGMSettings));
/* Allocate file name, and copy file name buffer to our structure */
}
return M4ERR_ALLOC;
}
- M4OSA_memcpy(pEditSavingSettings->xVSS.pBGMtrack->pFile,
- xVSS_context->pSettings->xVSS.pBGMtrack->pFile,
+ memcpy((void *)pEditSavingSettings->xVSS.pBGMtrack->pFile,
+ (void *)xVSS_context->pSettings->xVSS.pBGMtrack->pFile,
strlen(xVSS_context->pSettings->xVSS.pBGMtrack->pFile)
+ 1);
}
return M4ERR_ALLOC;
}
- M4OSA_memcpy(pEditSavingSettings->xVSS.pBGMtrack->pFile,
- pDecodedPath, length + 1);
+ memcpy((void *)pEditSavingSettings->xVSS.pBGMtrack->pFile,
+ (void *)pDecodedPath, length + 1);
}
/**/
}
return M4ERR_ALLOC;
}
- M4OSA_memcpy(xVSS_context->pCurrentEditSettings->pOutputFile,
- pDecodedPath, length + 1);
+ memcpy((void *)xVSS_context->pCurrentEditSettings->pOutputFile,
+ (void *)pDecodedPath, length + 1);
xVSS_context->pCurrentEditSettings->uiOutputPathSize = length + 1;
/**
}
return M4ERR_ALLOC;
}
- M4OSA_memcpy(xVSS_context->pCurrentEditSettings->pTemporaryFile,
- pDecodedPath, length + 1);
+ memcpy((void *)xVSS_context->pCurrentEditSettings->pTemporaryFile,
+ (void *)pDecodedPath, length + 1);
/* Put nb of step for progression monitoring to 2, because audio mixing is needed */
xVSS_context->nbStepTotal = 2;
- 1].filePathSize
== pVSSContext->pClipList[i].filePathSize )
{
- cmpResult = M4OSA_memcmp(pVSSContext->
+ cmpResult = memcmp((void *)pVSSContext->
pClipList[pVSSContext->uiCurrentClip
- - 1].pFile, pVSSContext->pClipList[i].pFile,
+ - 1].pFile, (void *)pVSSContext->pClipList[i].pFile,
pVSSContext->
pClipList[pVSSContext->uiCurrentClip
- 1].filePathSize);
if(pC->m_mediaRendering == M4xVSS_kBlackBorders)
{
- M4OSA_memset((M4OSA_MemAddr8)pImagePlanes[0].pac_data,
- (pImagePlanes[0].u_height*pImagePlanes[0].u_stride),Y_PLANE_BORDER_VALUE);
- M4OSA_memset((M4OSA_MemAddr8)pImagePlanes[1].pac_data,
- (pImagePlanes[1].u_height*pImagePlanes[1].u_stride),U_PLANE_BORDER_VALUE);
- M4OSA_memset((M4OSA_MemAddr8)pImagePlanes[2].pac_data,
- (pImagePlanes[2].u_height*pImagePlanes[2].u_stride),V_PLANE_BORDER_VALUE);
+ memset((void *)pImagePlanes[0].pac_data,Y_PLANE_BORDER_VALUE,
+ (pImagePlanes[0].u_height*pImagePlanes[0].u_stride));
+ memset((void *)pImagePlanes[1].pac_data,U_PLANE_BORDER_VALUE,
+ (pImagePlanes[1].u_height*pImagePlanes[1].u_stride));
+ memset((void *)pImagePlanes[2].pac_data,V_PLANE_BORDER_VALUE,
+ (pImagePlanes[2].u_height*pImagePlanes[2].u_stride));
/**
First without pan&zoom*/
for(i=0;i<rgbPlane.u_height;i++)
{
- M4OSA_memcpy((M4OSA_MemAddr8)output_pac_data, (M4OSA_MemAddr8)input_pac_data,
+ memcpy((void *)output_pac_data, (void *)input_pac_data,
(rgbPlane.u_width-1)*2);
output_pac_data += ((rgbPlane.u_width-1)*2);
switch (ColorContext->colorEffectType)
{
case M4xVSS_kVideoEffectType_BlackAndWhite:
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,
- PlaneIn[plane_number].u_width, 128);
+ memset((void *)p_buf_dest,128,
+ PlaneIn[plane_number].u_width);
break;
case M4xVSS_kVideoEffectType_Pink:
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,
- PlaneIn[plane_number].u_width, 255);
+ memset((void *)p_buf_dest,255,
+ PlaneIn[plane_number].u_width);
break;
case M4xVSS_kVideoEffectType_Green:
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,
- PlaneIn[plane_number].u_width, 0);
+ memset((void *)p_buf_dest,0,
+ PlaneIn[plane_number].u_width);
break;
case M4xVSS_kVideoEffectType_Sepia:
if(plane_number==1)
{
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,
- PlaneIn[plane_number].u_width, 117);
+ memset((void *)p_buf_dest,117,
+ PlaneIn[plane_number].u_width);
}
else
{
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,
- PlaneIn[plane_number].u_width, 139);
+ memset((void *)p_buf_dest,139,
+ PlaneIn[plane_number].u_width);
}
break;
case M4xVSS_kVideoEffectType_Negative:
- M4OSA_memcpy((M4OSA_MemAddr8)p_buf_dest,
- (M4OSA_MemAddr8)p_buf_src ,PlaneOut[plane_number].u_width);
+ memcpy((void *)p_buf_dest,
+ (void *)p_buf_src ,PlaneOut[plane_number].u_width);
break;
case M4xVSS_kVideoEffectType_ColorRGB16:
{
/*then convert to u*/
u = U16(r, g, b);
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,
- PlaneIn[plane_number].u_width, (M4OSA_UInt8)u);
+ memset((void *)p_buf_dest,(M4OSA_UInt8)u,
+ PlaneIn[plane_number].u_width);
}
if(plane_number==2)
{
/*then convert to v*/
v = V16(r, g, b);
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,
- PlaneIn[plane_number].u_width, (M4OSA_UInt8)v);
+ memset((void *)p_buf_dest, (M4OSA_UInt8)v,
+ PlaneIn[plane_number].u_width);
}
}
break;
{
/*then convert to u*/
u = U16(r, g, b);
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,
- PlaneIn[plane_number].u_width, (M4OSA_UInt8)u);
+ memset((void *)p_buf_dest,(M4OSA_UInt8)u,
+ PlaneIn[plane_number].u_width);
}
if(plane_number==2)
{
/*then convert to v*/
v = V16(r, g, b);
- M4OSA_memset((M4OSA_MemAddr8)p_buf_dest,
- PlaneIn[plane_number].u_width, (M4OSA_UInt8)v);
+ memset((void *)p_buf_dest,(M4OSA_UInt8)v,
+ PlaneIn[plane_number].u_width);
}
}
break;
}
break;
default:
- M4OSA_memcpy((M4OSA_MemAddr8)p_buf_dest,
- (M4OSA_MemAddr8)p_buf_src ,PlaneOut[plane_number].u_width);
+ memcpy((void *)p_buf_dest,
+ (void *)p_buf_src ,PlaneOut[plane_number].u_width);
break;
}
}
for (x = 0; x < pPlaneOut[plane_number].u_height; x++)
{
if (1 == plane_number)
- M4OSA_memset((M4OSA_MemAddr8)pOutCr, pPlaneIn[plane_number].u_width,
- 117); /* U value */
+ memset((void *)pOutCr, 117,pPlaneIn[plane_number].u_width); /* U value */
else
- M4OSA_memset((M4OSA_MemAddr8)pOutCr, pPlaneIn[plane_number].u_width,
- 139); /* V value */
+ memset((void *)pOutCr, 139,pPlaneIn[plane_number].u_width); /* V value */
pInCr += pPlaneIn[plane_number].u_stride;
pOutCr += pPlaneOut[plane_number].u_stride;
for (y=0; y<height; y++)
{
- M4OSA_memcpy((M4OSA_MemAddr8)destWalk, (M4OSA_MemAddr8)sourceWalk, width);
+ memcpy((void *)destWalk, (void *)sourceWalk, width);
destWalk += destStride;
sourceWalk += sourceStride;
}
/* First the part from the top source clip frame. */
for (y=0; y<topPartHeight; y++)
{
- M4OSA_memcpy((M4OSA_MemAddr8)destWalk, (M4OSA_MemAddr8)sourceWalk, width);
+ memcpy((void *)destWalk, (void *)sourceWalk, width);
destWalk += destStride;
sourceWalk += sourceStride;
}
for (y=0; y<bottomPartHeight; y++)
{
- M4OSA_memcpy((M4OSA_MemAddr8)destWalk, (M4OSA_MemAddr8)sourceWalk, width);
+ memcpy((void *)destWalk, (void *)sourceWalk, width);
destWalk += destStride;
sourceWalk += sourceStride;
}
for (y=0; y<height; y++)
{
- M4OSA_memcpy((M4OSA_MemAddr8)destWalkLeft, (M4OSA_MemAddr8)leftWalk, leftPartWidth);
+ memcpy((void *)destWalkLeft, (void *)leftWalk, leftPartWidth);
leftWalk += leftStride;
- M4OSA_memcpy((M4OSA_MemAddr8)destWalkRight, (M4OSA_MemAddr8)rightWalk, rightPartWidth);
+ memcpy((void *)destWalkRight, (void *)rightWalk, rightPartWidth);
rightWalk += rightStride;
destWalkLeft += destStride;
{
M4OSA_UInt32 ConvertedSize = xVSS_context->UTFConversionContext.m_TempOutConversionSize;
- M4OSA_memset((M4OSA_MemAddr8)xVSS_context->UTFConversionContext.pTempOutConversionBuffer
- ,(M4OSA_UInt32)xVSS_context->UTFConversionContext.m_TempOutConversionSize,0);
+ memset((void *)xVSS_context->UTFConversionContext.pTempOutConversionBuffer,0
+ ,(M4OSA_UInt32)xVSS_context->UTFConversionContext.m_TempOutConversionSize);
err = xVSS_context->UTFConversionContext.pConvToUTF8Fct((M4OSA_Void*)pBufferIn,
(M4OSA_UInt8*)xVSS_context->UTFConversionContext.pTempOutConversionBuffer,
}
xVSS_context->UTFConversionContext.m_TempOutConversionSize = ConvertedSize;
- M4OSA_memset((M4OSA_MemAddr8)xVSS_context->\
- UTFConversionContext.pTempOutConversionBuffer,(M4OSA_UInt32)xVSS_context->\
- UTFConversionContext.m_TempOutConversionSize,0);
+ memset((void *)xVSS_context->\
+ UTFConversionContext.pTempOutConversionBuffer,0,(M4OSA_UInt32)xVSS_context->\
+ UTFConversionContext.m_TempOutConversionSize);
err = xVSS_context->UTFConversionContext.pConvToUTF8Fct((M4OSA_Void*)pBufferIn,
(M4OSA_Void*)xVSS_context->UTFConversionContext.pTempOutConversionBuffer,
{
M4OSA_UInt32 ConvertedSize = xVSS_context->UTFConversionContext.m_TempOutConversionSize;
- M4OSA_memset((M4OSA_MemAddr8)xVSS_context->\
- UTFConversionContext.pTempOutConversionBuffer,(M4OSA_UInt32)xVSS_context->\
- UTFConversionContext.m_TempOutConversionSize,0);
+ memset((void *)xVSS_context->\
+ UTFConversionContext.pTempOutConversionBuffer,0,(M4OSA_UInt32)xVSS_context->\
+ UTFConversionContext.m_TempOutConversionSize);
err = xVSS_context->UTFConversionContext.pConvFromUTF8Fct\
((M4OSA_Void*)pBufferIn,(M4OSA_UInt8*)xVSS_context->\
}
xVSS_context->UTFConversionContext.m_TempOutConversionSize = ConvertedSize;
- M4OSA_memset((M4OSA_MemAddr8)xVSS_context->\
- UTFConversionContext.pTempOutConversionBuffer,(M4OSA_UInt32)xVSS_context->\
- UTFConversionContext.m_TempOutConversionSize,0);
+ memset((void *)xVSS_context->\
+ UTFConversionContext.pTempOutConversionBuffer,0,(M4OSA_UInt32)xVSS_context->\
+ UTFConversionContext.m_TempOutConversionSize);
err = xVSS_context->UTFConversionContext.pConvFromUTF8Fct((M4OSA_Void*)pBufferIn,
(M4OSA_Void*)xVSS_context->UTFConversionContext.pTempOutConversionBuffer,
{ \
(p) = (type*)M4OSA_malloc(sizeof(type)*(count), 0xFF,(M4OSA_Char*)comment);\
VIDEOEDITOR_CHECK(M4OSA_NULL != (p), M4ERR_ALLOC); \
- M4OSA_memset((M4OSA_MemAddr8)(p), sizeof(type)*(count), 0); \
+ memset((void *)(p), 0,sizeof(type)*(count)); \
}
}
pAu->size = mMediaBuffer->range_length();
- memcpy((M4OSA_MemAddr8)pAu->dataAddress,
- (const char *)mMediaBuffer->data() + mMediaBuffer->range_offset(),
+ memcpy((void *)pAu->dataAddress,
+ (void *)((const char *)mMediaBuffer->data() + mMediaBuffer->range_offset()),
mMediaBuffer->range_length());
if( (pStreamHandler == (M4_StreamHandler*)pC->mVideoStreamHandler) &&
goto cleanup;
}
- M4OSA_memcpy((M4OSA_MemAddr8 ) pStreamHandler->m_pH264DecoderSpecificInfo,
- (M4OSA_MemAddr8 )pDecoderConfigLocal,
+ memcpy((void * ) pStreamHandler->m_pH264DecoderSpecificInfo,
+ (void * )pDecoderConfigLocal,
pStreamHandler->m_H264decoderSpecificInfoSize);
return M4NO_ERROR;
cleanup:
if (M4OSA_NULL == DecoderSpecific) {
return M4ERR_ALLOC;
}
- M4OSA_memcpy((M4OSA_MemAddr8)DecoderSpecific,
- (M4OSA_MemAddr8)data, size);
+ memcpy((void *)DecoderSpecific,
+ (void *)data, size);
(*pStreamHandler)->m_pDecoderSpecificInfo =
DecoderSpecific;
}
LOGV("VideoEditor3gp_getNextStream is NULL ");
return M4ERR_ALLOC;
}
- M4OSA_memcpy((M4OSA_MemAddr8)DecoderSpecificInfo,
- (M4OSA_MemAddr8)data, decoderSpecificInfoSize);
+ memcpy((void *)DecoderSpecificInfo,
+ (void *)data, decoderSpecificInfoSize);
} else {
LOGV("DSI Size %d", decoderSpecificInfoSize);
DecoderSpecificInfo = M4OSA_NULL;
if (M4OSA_NULL == (*pStreamHandler)->m_pESDSInfo) {
return M4ERR_ALLOC;
}
- M4OSA_memcpy((M4OSA_MemAddr8)(*pStreamHandler)->\
- m_pESDSInfo, (M4OSA_MemAddr8)data, size);
+ memcpy((void *)(*pStreamHandler)->\
+ m_pESDSInfo, (void *)data, size);
esds.getCodecSpecificInfo(&codec_specific_data,
&codec_specific_data_size);
if (M4OSA_NULL == DecoderSpecific) {
return M4ERR_ALLOC;
}
- M4OSA_memcpy((M4OSA_MemAddr8)DecoderSpecific,
- (M4OSA_MemAddr8)codec_specific_data,
+ memcpy((void *)DecoderSpecific,
+ (void *)codec_specific_data,
codec_specific_data_size);
(*pStreamHandler)->m_pDecoderSpecificInfo =
DecoderSpecific;
if (M4OSA_NULL == DecoderSpecific) {
return M4ERR_ALLOC;
}
- M4OSA_memcpy((M4OSA_MemAddr8)DecoderSpecific,
- (M4OSA_MemAddr8)codec_specific_data,
+ memcpy((void *)DecoderSpecific,
+ (void *)codec_specific_data,
codec_specific_data_size);
(*pStreamHandler)->m_pDecoderSpecificInfo =
DecoderSpecific;
if (M4OSA_NULL == (*pStreamHandler)->m_pESDSInfo) {
return M4ERR_ALLOC;
}
- M4OSA_memcpy((M4OSA_MemAddr8)(*pStreamHandler)->m_pESDSInfo,
- (M4OSA_MemAddr8)data, size);
+ memcpy((void *)(*pStreamHandler)->m_pESDSInfo,
+ (void *)data, size);
esds.getCodecSpecificInfo(&codec_specific_data,
&codec_specific_data_size);
if (M4OSA_NULL == DecoderSpecific) {
return M4ERR_ALLOC;
}
- M4OSA_memcpy((M4OSA_MemAddr8)DecoderSpecific,
- (M4OSA_MemAddr8)codec_specific_data,
+ memcpy((void *)DecoderSpecific,
+ (void *)codec_specific_data,
codec_specific_data_size);
(*pStreamHandler)->m_pDecoderSpecificInfo =
DecoderSpecific;
// Copy the stream properties into userdata
if( M4OSA_NULL != pUserData ) {
- M4OSA_memcpy((M4OSA_MemAddr8)pUserData,
- (M4OSA_MemAddr8)&aacProperties,
+ memcpy((void *)pUserData,
+ (void *)&aacProperties,
sizeof(AAC_DEC_STREAM_PROPS));
}
break;
if( M4OSA_NULL != pInputBuffer ) {
buffer = new MediaBuffer((size_t)pInputBuffer->m_bufferSize);
- M4OSA_memcpy((M4OSA_Int8*)buffer->data() + buffer->range_offset(),
- pInputBuffer->m_dataAddress, pInputBuffer->m_bufferSize);
+ memcpy((void *)((M4OSA_Int8*)buffer->data() + buffer->range_offset()),
+ (void *)pInputBuffer->m_dataAddress, pInputBuffer->m_bufferSize);
}
nbBuffer = pDecoderContext->mDecoderSource->storeBuffer(buffer);
(M4OSA_UInt32)pDecoderContext->mNbOutputChannels ) {
// Just copy the PCMs
pOuputBuffer->m_bufferSize = (M4OSA_UInt32)buffer->range_length();
- M4OSA_memcpy(pOuputBuffer->m_dataAddress,
- ((M4OSA_MemAddr8)buffer->data())+buffer->range_offset(),
+ memcpy((void *)pOuputBuffer->m_dataAddress,
+ (void *)(((M4OSA_MemAddr8)buffer->data())+buffer->range_offset()),
buffer->range_length());
} else if( pDecoderContext->mAudioStreamHandler->m_nbChannels <
(M4OSA_UInt32)pDecoderContext->mNbOutputChannels ) {
SAFE_MALLOC(pEncoderContext->mDSI.pInfo, M4OSA_Int8,
pEncoderContext->mDSI.infoSize, "Encoder header");
- M4OSA_memcpy(pEncoderContext->mDSI.pInfo,
- (M4OSA_MemAddr8)(buffer->data())+buffer->range_offset(),
+ memcpy((void *)pEncoderContext->mDSI.pInfo,
+ (void *)((M4OSA_MemAddr8)(buffer->data())+buffer->range_offset()),
pEncoderContext->mDSI.infoSize);
buffer->release();
// Let the MediaBuffer own the data so we don't have to free it
buffer = new MediaBuffer((size_t)pInBuffer->pTableBufferSize[0]);
pData = (M4OSA_Int8*)buffer->data() + buffer->range_offset();
- M4OSA_memcpy(pData, pInBuffer->pTableBuffer[0],
+ memcpy((void *)pData, (void *)pInBuffer->pTableBuffer[0],
pInBuffer->pTableBufferSize[0]);
break;
default:
pEncoderContext->mLastOutputCts = i64Tmp;
// Format the AU
- M4OSA_memcpy(pOutBuffer->pTableBuffer[0],
- (M4OSA_MemAddr8)(buffer->data())+buffer->range_offset(),
+ memcpy((void *)pOutBuffer->pTableBuffer[0],
+ (void *)((M4OSA_MemAddr8)(buffer->data())+buffer->range_offset()),
buffer->range_length());
pOutBuffer->pTableBufferSize[0] = (M4OSA_UInt32)buffer->range_length();
}
LOGV("VIDEOEDITOR_BUFFER_allocatePool : Assigning Pool name buffer");
- M4OSA_memset(pool->poolName, VIDEOEDITOR_BUFFEPOOL_MAX_NAME_SIZE, 0);
- M4OSA_memcpy(pool->poolName, poolName,
+ memset((void *)pool->poolName, 0,VIDEOEDITOR_BUFFEPOOL_MAX_NAME_SIZE);
+ memcpy((void *)pool->poolName, (void *)poolName,
VIDEOEDITOR_BUFFEPOOL_MAX_NAME_SIZE-1);
pool->NB = nbBuffers;
? (M4OSA_UInt32)mMaxAUSize : pAccessUnit->m_size;
LOGV("VideoDecoderSource:Read() copying AU to i/p buffer of decoder,"
"Bufer Add = 0x%x, size = %d", mBuffer->data(), lSize);
- M4OSA_memcpy((M4OSA_MemAddr8)mBuffer->data(),pAccessUnit->m_dataAddress,
+ memcpy((void *)mBuffer->data(),(void *)pAccessUnit->m_dataAddress,
lSize);
mBuffer->set_range(0, lSize);
(uint16_t *) &(PlaneOut[2].pac_data[PlaneOut[2].u_topleft]);
/* Y copying */
- memcpy(outy, inyuv, outYsize);
+ memcpy((void *)outy, (void *)inyuv, outYsize);
/* U & V copying */
uint32_t *inyuv_4 = (uint32_t *) (inyuv + outYsize);
{
M4OSA_MemAddr8 pTmpBuff = (M4OSA_MemAddr8)pDecoderBuffer->data() + pDecoderBuffer->range_offset();
- M4OSA_memcpy((M4OSA_MemAddr8)tmpDecBuffer->pData, pTmpBuff, yPlaneSize);
+ memcpy((void *)tmpDecBuffer->pData, (void *)pTmpBuff, yPlaneSize);
offsetSrc += pDecShellContext->mGivenWidth * pDecShellContext->mGivenHeight;
- M4OSA_memcpy((M4OSA_MemAddr8)tmpDecBuffer->pData + yPlaneSize,
- pTmpBuff + offsetSrc, uvPlaneSize);
+ memcpy((void *)((M4OSA_MemAddr8)tmpDecBuffer->pData + yPlaneSize),
+ (void *)(pTmpBuff + offsetSrc), uvPlaneSize);
offsetSrc += (pDecShellContext->mGivenWidth >> 1) * (pDecShellContext->mGivenHeight >> 1);
- M4OSA_memcpy((M4OSA_MemAddr8)tmpDecBuffer->pData + yPlaneSize + uvPlaneSize,
- pTmpBuff + offsetSrc, uvPlaneSize);
+ memcpy((void *)((M4OSA_MemAddr8)tmpDecBuffer->pData + yPlaneSize + uvPlaneSize),
+ (void *)(pTmpBuff + offsetSrc), uvPlaneSize);
}
else
{
for ( index = 0; index < height; index++)
{
- memcpy(pTmpBuffDst, pTmpBuff, width);
+ memcpy((void *)pTmpBuffDst, (void *)pTmpBuff, width);
pTmpBuffDst += width;
pTmpBuff += pDecShellContext->mGivenWidth;
}
pTmpBuff += (pDecShellContext->mGivenWidth * ( pDecShellContext->mGivenHeight - height));
for ( index = 0; index < height >> 1; index++)
{
- memcpy(pTmpBuffDst, pTmpBuff, width >> 1);
+ memcpy((void *)pTmpBuffDst, (void *)pTmpBuff, width >> 1);
pTmpBuffDst += width >> 1;
pTmpBuff += pDecShellContext->mGivenWidth >> 1;
}
pTmpBuff += ((pDecShellContext->mGivenWidth * (pDecShellContext->mGivenHeight - height)) / 4);
for ( index = 0; index < height >> 1; index++)
{
- memcpy(pTmpBuffDst, pTmpBuff, width >> 1);
+ memcpy((void *)pTmpBuffDst, (void *)pTmpBuff, width >> 1);
pTmpBuffDst += width >> 1;
pTmpBuff += pDecShellContext->mGivenWidth >> 1;
}
M4OSA_UInt32 tempHeight =
pDecShellContext->m_pVideoStreamhandler->m_videoHeight;
- M4OSA_memcpy((M4OSA_MemAddr8) pOutputPlane[0].pac_data, tempBuffPtr,
+ memcpy((void *) pOutputPlane[0].pac_data, (void *)tempBuffPtr,
tempWidth * tempHeight);
tempBuffPtr += (tempWidth * tempHeight);
- M4OSA_memcpy((M4OSA_MemAddr8) pOutputPlane[1].pac_data, tempBuffPtr,
+ memcpy((void *) pOutputPlane[1].pac_data, (void *)tempBuffPtr,
(tempWidth/2) * (tempHeight/2));
tempBuffPtr += ((tempWidth/2) * (tempHeight/2));
- M4OSA_memcpy((M4OSA_MemAddr8) pOutputPlane[2].pac_data, tempBuffPtr,
+ memcpy((void *) pOutputPlane[2].pac_data, (void *)tempBuffPtr,
(tempWidth/2) * (tempHeight/2));
}
(M4OSA_UInt32)outputBuffer->range_length();
SAFE_MALLOC(pEncoderContext->mHeader.pBuf, M4OSA_Int8,
pEncoderContext->mHeader.Size, "Encoder header");
- M4OSA_memcpy(pEncoderContext->mHeader.pBuf,
- (M4OSA_MemAddr8)(outputBuffer->data())+outputBuffer->range_offset(),
+ memcpy((void *)pEncoderContext->mHeader.pBuf,
+ (void *)((M4OSA_MemAddr8)(outputBuffer->data())+outputBuffer->range_offset()),
pEncoderContext->mHeader.Size);
outputBuffer->release();
}
(M4OSA_UInt32)buffer->range_length();
SAFE_MALLOC(pEncoderContext->mHeader.pBuf, M4OSA_Int8,
pEncoderContext->mHeader.Size, "Encoder header");
- M4OSA_memcpy(pEncoderContext->mHeader.pBuf,
- (M4OSA_MemAddr8)(buffer->data())+buffer->range_offset(),
+ memcpy((void *)pEncoderContext->mHeader.pBuf,
+ (void *)((M4OSA_MemAddr8)(buffer->data())+buffer->range_offset()),
pEncoderContext->mHeader.Size);
}
#endif /* VIDEOEDITOR_ENCODER_GET_DSI_AT_CREATION */
pEncoderContext->mAccessUnit->size = (M4OSA_UInt32)outputSize;
} else {
// The AU can just be copied
- M4OSA_memcpy((M4OSA_MemAddr8)pEncoderContext->mAccessUnit->\
- dataAddress, (M4OSA_MemAddr8)(buffer->data())+buffer->\
- range_offset(), buffer->range_length());
+ memcpy((void *)pEncoderContext->mAccessUnit->\
+ dataAddress, (void *)((M4OSA_MemAddr8)(buffer->data())+buffer->\
+ range_offset()), buffer->range_length());
pEncoderContext->mAccessUnit->size =
(M4OSA_UInt32)buffer->range_length();
}
/* very specific case : set luma plane to 16 */
for (j = u_height; j != 0; j--)
{
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 16);
+ memset((void *)p_dest,16, u_width);
p_dest += u_stride_out;
}
return 0;
/* very specific case : set luma plane to 16 */
for (j = u_height; j != 0; j--)
{
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 16);
+ memset((void *)p_dest, 16,u_width);
p_dest += u_stride_out;
}
return 0;
{
for (i = u_width; i != 0; i--)
{
- M4OSA_memcpy((M4OSA_MemAddr8)p_cdest_line, (M4OSA_MemAddr8)p_csrc_line, u_width);
- M4OSA_memcpy((M4OSA_MemAddr8)p_cdest,(M4OSA_MemAddr8) p_csrc, u_width);
+ memcpy((void *)p_cdest_line, (void *)p_csrc_line, u_width);
+ memcpy((void *)p_cdest,(void *) p_csrc, u_width);
}
p_cdest_line += u_stride_out;
p_cdest += u_stride_out;
for (j = (nb_black_lines >> 1); j != 0; j--)
{ /* set black lines */
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 0);
+ memset((void *)p_dest, 0,u_width);
p_dest += u_stride_out;
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 0);
+ memset((void *)p_dest, 0,u_width);
p_dest += u_stride_out;
- M4OSA_memset((M4OSA_MemAddr8)p_destu, u_widthuv, 128);
- M4OSA_memset((M4OSA_MemAddr8)p_destv, u_widthuv, 128);
+ memset((void *)p_destu, 128,u_widthuv);
+ memset((void *)p_destv, 128,u_widthuv);
p_destu += u_stride_out_uv;
p_destv += u_stride_out_uv;
}
/* copy other lines from source */
for (j = (u_height - nb_black_lines) >> 1; j != 0; j--)
{
- M4OSA_memcpy((M4OSA_MemAddr8)p_dest, (M4OSA_MemAddr8)p_src, u_width);
+ memcpy((void *)p_dest, (void *)p_src, u_width);
p_dest += u_stride_out;
p_src += u_stride;
- M4OSA_memcpy((M4OSA_MemAddr8)p_dest,(M4OSA_MemAddr8) p_src, u_width);
+ memcpy((void *)p_dest,(void *) p_src, u_width);
p_dest += u_stride_out;
p_src += u_stride;
- M4OSA_memcpy((M4OSA_MemAddr8)p_destu,(M4OSA_MemAddr8) p_srcu, u_widthuv);
- M4OSA_memcpy((M4OSA_MemAddr8)p_destv, (M4OSA_MemAddr8)p_srcv, u_widthuv);
+ memcpy((void *)p_destu,(void *) p_srcu, u_widthuv);
+ memcpy((void *)p_destv, (void *)p_srcv, u_widthuv);
p_destu += u_stride_out_uv;
p_destv += u_stride_out_uv;
p_srcu += u_stride_uv;
for (j = (u_height - nb_black_lines) >> 1; j != 0; j--)
{
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 0);
+ memset((void *)p_dest, 0,u_width);
p_dest += u_stride_out;
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 0);
+ memset((void *)p_dest,0, u_width);
p_dest += u_stride_out;
- M4OSA_memset((M4OSA_MemAddr8)p_destu, u_widthuv, 128);
- M4OSA_memset((M4OSA_MemAddr8)p_destv, u_widthuv, 128);
+ memset((void *)p_destu, 128,u_widthuv);
+ memset((void *)p_destv, 128,u_widthuv);
p_destu += u_stride_out_uv;
p_destv += u_stride_out_uv;
}
for (j = (nb_black_lines >> 1); j != 0; j--)
{
- M4OSA_memcpy((M4OSA_MemAddr8)p_dest,(M4OSA_MemAddr8) p_src, u_width);
+ memcpy((void *)p_dest,(void *) p_src, u_width);
p_dest += u_stride_out;
p_src += u_stride;
- M4OSA_memcpy((M4OSA_MemAddr8)p_dest,(M4OSA_MemAddr8) p_src, u_width);
+ memcpy((void *)p_dest,(void *) p_src, u_width);
p_dest += u_stride_out;
p_src += u_stride;
- M4OSA_memcpy((M4OSA_MemAddr8)p_destu,(M4OSA_MemAddr8) p_srcu, u_widthuv);
- M4OSA_memcpy((M4OSA_MemAddr8)p_destv, (M4OSA_MemAddr8)p_srcv, u_widthuv);
+ memcpy((void *)p_destu,(void *) p_srcu, u_widthuv);
+ memcpy((void *)p_destv, (void *)p_srcv, u_widthuv);
p_destu += u_stride_out_uv;
p_destv += u_stride_out_uv;
p_srcu += u_stride_uv;
p_srcv += u_stride_uv;
}
-/* p_destu = (unsigned char *) &plane_out[1].pac_data[plane_out[1].u_topleft];
- p_destv = (unsigned char *) &plane_out[2].pac_data[plane_out[2].u_topleft];
- for (j = (u_height >> 1); j != 0; j--)
- {
- M4OSA_memset(p_destu, u_widthuv, 128);
- M4OSA_memset(p_destv, u_widthuv, 128);
- p_destu += u_stride_out_uv;
- p_destv += u_stride_out_uv;
- }
-*/
return 0;
}
for (j = (nb_black_lines >> 1); j != 0; j--)
{
- M4OSA_memcpy((M4OSA_MemAddr8)p_dest,(M4OSA_MemAddr8) p_src, u_width);
+ memcpy((void *)p_dest,(void *) p_src, u_width);
p_dest += u_stride_out;
p_src += u_stride;
- M4OSA_memcpy((M4OSA_MemAddr8)p_dest,(M4OSA_MemAddr8) p_src, u_width);
+ memcpy((void *)p_dest,(void *) p_src, u_width);
p_dest += u_stride_out;
p_src += u_stride;
- M4OSA_memcpy((M4OSA_MemAddr8)p_destu,(M4OSA_MemAddr8) p_srcu, u_widthuv);
- M4OSA_memcpy((M4OSA_MemAddr8)p_destv,(M4OSA_MemAddr8) p_srcv, u_widthuv);
+ memcpy((void *)p_destu,(void *) p_srcu, u_widthuv);
+ memcpy((void *)p_destv,(void *) p_srcv, u_widthuv);
p_destu += u_stride_out_uv;
p_destv += u_stride_out_uv;
p_srcu += u_stride_uv;
for (j = (u_height - nb_black_lines) >> 1; j != 0; j--)
{
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 0);
+ memset((void *)p_dest, 0,u_width);
p_dest += u_stride_out;
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 0);
+ memset((void *)p_dest, 0,u_width);
p_dest += u_stride_out;
- M4OSA_memset((M4OSA_MemAddr8)p_destu, u_widthuv, 128);
- M4OSA_memset((M4OSA_MemAddr8)p_destv, u_widthuv, 128);
+ memset((void *)p_destu, 128,u_widthuv);
+ memset((void *)p_destv, 128,u_widthuv);
p_destu += u_stride_out_uv;
p_destv += u_stride_out_uv;
}
/* write black lines */
for (j = (nb_black_lines >> 1); j != 0; j--)
{
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 0);
+ memset((void *)p_dest, 0,u_width);
p_dest += u_stride_out;
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 0);
+ memset((void *)p_dest, 0,u_width);
p_dest += u_stride_out;
- M4OSA_memset((M4OSA_MemAddr8)p_destu, u_widthuv, 128);
- M4OSA_memset((M4OSA_MemAddr8)p_destv, u_widthuv, 128);
+ memset((void *)p_destu, 128,u_widthuv);
+ memset((void *)p_destv, 128,u_widthuv);
p_destu += u_stride_out_uv;
p_destv += u_stride_out_uv;
}
/* copy from source image */
for (j = (u_height - nb_black_lines) >> 1; j != 0; j--)
{
- M4OSA_memcpy((M4OSA_MemAddr8)p_dest, (M4OSA_MemAddr8)p_src, u_width);
+ memcpy((void *)p_dest, (void *)p_src, u_width);
p_dest += u_stride_out;
p_src += u_stride;
- M4OSA_memcpy((M4OSA_MemAddr8)p_dest,(M4OSA_MemAddr8) p_src, u_width);
+ memcpy((void *)p_dest,(void *) p_src, u_width);
p_dest += u_stride_out;
p_src += u_stride;
- M4OSA_memcpy((M4OSA_MemAddr8)p_destu,(M4OSA_MemAddr8) p_srcu, u_widthuv);
- M4OSA_memcpy((M4OSA_MemAddr8)p_destv, (M4OSA_MemAddr8)p_srcv, u_widthuv);
+ memcpy((void *)p_destu,(void *) p_srcu, u_widthuv);
+ memcpy((void *)p_destv, (void *)p_srcv, u_widthuv);
p_destu += u_stride_out_uv;
p_destv += u_stride_out_uv;
p_srcu += u_stride_uv;
/* copy from source image image */
for (j = (nb_black_lines >> 1); j != 0; j--)
{
- M4OSA_memcpy((M4OSA_MemAddr8)p_dest, (M4OSA_MemAddr8)p_src, u_width);
+ memcpy((void *)p_dest, (void *)p_src, u_width);
p_dest += u_stride_out;
p_src += u_stride;
- M4OSA_memcpy((M4OSA_MemAddr8)p_dest,(M4OSA_MemAddr8) p_src, u_width);
+ memcpy((void *)p_dest,(void *) p_src, u_width);
p_dest += u_stride_out;
p_src += u_stride;
- M4OSA_memcpy((M4OSA_MemAddr8)p_destu,(M4OSA_MemAddr8) p_srcu, u_widthuv);
- M4OSA_memcpy((M4OSA_MemAddr8)p_destv,(M4OSA_MemAddr8) p_srcv, u_widthuv);
+ memcpy((void *)p_destu,(void *) p_srcu, u_widthuv);
+ memcpy((void *)p_destv,(void *) p_srcv, u_widthuv);
p_destu += u_stride_out_uv;
p_destv += u_stride_out_uv;
p_srcu += u_stride_uv;
/* the pointers to p_dest, p_destu and p_destv are used through the two loops "for" */
for (j = (u_height - nb_black_lines) >> 1; j != 0; j--)
{
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 0);
+ memset((void *)p_dest, 0,u_width);
p_dest += u_stride_out;
- M4OSA_memset((M4OSA_MemAddr8)p_dest, u_width, 0);
+ memset((void *)p_dest, 0,u_width);
p_dest += u_stride_out;
- M4OSA_memset((M4OSA_MemAddr8)p_destu, u_widthuv, 128);
- M4OSA_memset((M4OSA_MemAddr8)p_destv, u_widthuv, 128);
+ memset((void *)p_destu, 128,u_widthuv);
+ memset((void *)p_destv, 128,u_widthuv);
p_destu += u_stride_out_uv;
p_destv += u_stride_out_uv;
}
OSDN Git Service
