generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactored vie_file_image.

Browse Source 
Review URL: http://webrtc-codereview.appspot.com/332002

git-svn-id: http://webrtc.googlecode.com/svn/trunk@1214 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
mflodman@webrtc.org 2011-12-16 08:52:41 +00:00
parent ed716e42eb
commit 352dcd8b2d
2 changed files with 94 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
src/video_engine/vie_file_image.cc
View File

@ -8,110 +8,97 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
/* // Placed first to get WEBRTC_VIDEO_ENGINE_FILE_API.
* vie_file_image.cc
*/
#include "engine_configurations.h" #include "engine_configurations.h"
#ifdef WEBRTC_VIDEO_ENGINE_FILE_API #ifdef WEBRTC_VIDEO_ENGINE_FILE_API
#include "video_engine/vie_file_image.h"
#include <stdio.h> #include <stdio.h>
#include "vie_file_image.h"
#include "video_image.h" #include "common_video/interface/video_image.h"
#include "jpeg.h" #include "common_video/jpeg/main/interface/jpeg.h"
#include "trace.h" #include "system_wrappers/interface/trace.h"
namespace webrtc { namespace webrtc {
int ViEFileImage::ConvertJPEGToVideoFrame(int engineId, int ViEFileImage::ConvertJPEGToVideoFrame(int engine_id,
const char* fileNameUTF8, const char* file_nameUTF8,
VideoFrame& videoFrame) VideoFrame& video_frame) {
{ // Read jpeg file into temporary buffer.
// read jpeg file into temporary buffer EncodedImage image_buffer;
EncodedImage imageBuffer;
FILE* imageFile = fopen(fileNameUTF8, "rb"); FILE* image_file = fopen(file_nameUTF8, "rb");
if (NULL == imageFile) if (!image_file) {
{ WEBRTC_TRACE(kTraceError, kTraceVideo, engine_id,
// error reading file "%s could not open file %s", __FUNCTION__, file_nameUTF8);
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, engineId,
"%s could not open file %s", __FUNCTION__, fileNameUTF8);
return -1; return -1;
} }
fseek(imageFile, 0, SEEK_END); fseek(image_file, 0, SEEK_END);
imageBuffer._size = ftell(imageFile); image_buffer._size = ftell(image_file);
fseek(imageFile, 0, SEEK_SET); fseek(image_file, 0, SEEK_SET);
imageBuffer._buffer = new WebRtc_UWord8[ imageBuffer._size + 1]; image_buffer._buffer = new WebRtc_UWord8[ image_buffer._size + 1];
if ( imageBuffer._size != fread(imageBuffer._buffer, sizeof(WebRtc_UWord8), if (image_buffer._size != fread(image_buffer._buffer, sizeof(WebRtc_UWord8),
imageBuffer._size, imageFile)) image_buffer._size, image_file)) {
{ WEBRTC_TRACE(kTraceError, kTraceVideo, engine_id,
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, engineId, "%s could not read file %s", __FUNCTION__, file_nameUTF8);
"%s could not read file %s", __FUNCTION__, fileNameUTF8); delete [] image_buffer._buffer;
delete [] imageBuffer._buffer;
return -1; return -1;
} }
fclose(imageFile); fclose(image_file);
// if this is a jpeg file, decode it
JpegDecoder decoder; JpegDecoder decoder;
RawImage decoded_image;
int ret = decoder.Decode(image_buffer, decoded_image);
int ret = 0; delete [] image_buffer._buffer;
image_buffer._buffer = NULL;
RawImage decodedImage; if (ret == -1) {
ret = decoder.Decode(imageBuffer, decodedImage); WEBRTC_TRACE(kTraceError, kTraceVideo, engine_id,
// done with this.
delete [] imageBuffer._buffer;
imageBuffer._buffer = NULL;
if (-1 == ret)
{
// error decoding the file
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, engineId,
"%s could decode file %s from jpeg format", __FUNCTION__, "%s could decode file %s from jpeg format", __FUNCTION__,
fileNameUTF8); file_nameUTF8);
return -1; return -1;
} else if (-3 == ret) } else if (ret == -3) {
{ WEBRTC_TRACE(kTraceError, kTraceVideo, engine_id,
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, engineId,
"%s could not convert jpeg's data to i420 format", "%s could not convert jpeg's data to i420 format",
__FUNCTION__, fileNameUTF8); __FUNCTION__, file_nameUTF8);
} }
WebRtc_UWord32 imageLength = (WebRtc_UWord32)(decodedImage._width * // Image length in I420.
decodedImage._height * 1.5); WebRtc_UWord32 image_length = (WebRtc_UWord32)(decoded_image._width *
if (-1 == videoFrame.Swap(decodedImage._buffer, imageLength, imageLength)) decoded_image._height * 1.5);
{ if (-1 == video_frame.Swap(decoded_image._buffer, image_length,
WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideo, image_length)) {
engineId, WEBRTC_TRACE(kTraceDebug, kTraceVideo, engine_id,
"%s could not copy frame imageDecodedBuffer to videoFrame ", "%s could not copy frame image_decoded_buffer to video_frame ",
__FUNCTION__, fileNameUTF8); __FUNCTION__, file_nameUTF8);
return -1; return -1;
} }
if (decodedImage._buffer) if (decoded_image._buffer) {
{ delete [] decoded_image._buffer;
delete [] decodedImage._buffer; decoded_image._buffer = NULL;
decodedImage._buffer = NULL;
} }
videoFrame.SetWidth(decodedImage._width); video_frame.SetWidth(decoded_image._width);
videoFrame.SetHeight(decodedImage._height); video_frame.SetHeight(decoded_image._height);
return 0; return 0;
} }
int ViEFileImage::ConvertPictureToVideoFrame(int engineId, int ViEFileImage::ConvertPictureToVideoFrame(int engine_id,
const ViEPicture& picture, const ViEPicture& picture,
VideoFrame& videoFrame) VideoFrame& video_frame) {
{ WebRtc_UWord32 picture_length = (WebRtc_UWord32)(picture.width *
WebRtc_UWord32 pictureLength = (WebRtc_UWord32)(picture.width picture.height * 1.5);
* picture.height * 1.5); video_frame.CopyFrame(picture_length, picture.data);
videoFrame.CopyFrame(pictureLength, picture.data); video_frame.SetWidth(picture.width);
videoFrame.SetWidth(picture.width); video_frame.SetHeight(picture.height);
videoFrame.SetHeight(picture.height); video_frame.SetLength(picture_length);
videoFrame.SetLength(pictureLength);
return 0; return 0;
} }
} // namespace webrtc } // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_FILE_API #endif // WEBRTC_VIDEO_ENGINE_FILE_API

32
src/video_engine/vie_file_image.h
View File

@ -8,27 +8,25 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
/* #ifndef WEBRTC_VIDEO_ENGINE_VIE_FILE_IMAGE_H_
* vie_file_image.h #define WEBRTC_VIDEO_ENGINE_VIE_FILE_IMAGE_H_
*/
#ifndef WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_FILE_IMAGE_H_
#define WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_FILE_IMAGE_H_
#include "modules/interface/module_common_types.h"
#include "typedefs.h" #include "typedefs.h"
#include "vie_file.h" #include "video_engine/main/interface/vie_file.h"
#include "module_common_types.h"
namespace webrtc { namespace webrtc {
class ViEFileImage
{ class ViEFileImage {
public: public:
static int ConvertJPEGToVideoFrame(int engineId, static int ConvertJPEGToVideoFrame(int engine_id,
const char* fileNameUTF8, const char* file_nameUTF8,
VideoFrame& videoFrame); VideoFrame& video_frame);
static int ConvertPictureToVideoFrame(int engineId, static int ConvertPictureToVideoFrame(int engine_id,
const ViEPicture& picture, const ViEPicture& picture,
VideoFrame& videoFrame); VideoFrame& video_frame);
}; };
} // namespace webrtc } // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_FILE_IMAGE_H_ #endif // WEBRTC_VIDEO_ENGINE_VIE_FILE_IMAGE_H_