void
OWLDiff::relation(const tags_t &attrs, const std::list<member> &members, const tags_t &tags) {
owl_diff::relation r(attrs, tags, members);
update_metadata(attrs);
list<owl_diff::change> changes = common(r, database, current_action);
all_changes.splice(all_changes.end(), changes);
}
void
OWLDiff::node(const tags_t &attrs, const tags_t &tags) {
owl_diff::node n(attrs, tags);
update_metadata(attrs);
list<owl_diff::change> changes = common(n, database, current_action);
all_changes.splice(all_changes.end(), changes);
}
void
OWLDiff::way(const tags_t &attrs, const std::vector<id_t> &way_nodes, const tags_t &tags) {
owl_diff::way w(attrs, tags, way_nodes);
update_metadata(attrs);
list<owl_diff::change> changes = common(w, database, current_action);
all_changes.splice(all_changes.end(), changes);
}
int main(int argc, char ** argv) {
int errcode;
/* flvmeta default options */
static flvmeta_opts options;
options.command = FLVMETA_DEFAULT_COMMAND;
options.input_file = NULL;
options.output_file = NULL;
options.metadata = NULL;
options.check_level = FLVMETA_CHECK_LEVEL_WARNING;
options.quiet = 0;
options.check_xml_report = 0;
options.dump_metadata = 0;
options.insert_onlastsecond = 1;
options.reset_timestamps = 0;
options.all_keyframes = 0;
options.preserve_metadata = 0;
options.error_handling = FLVMETA_EXIT_ON_ERROR;
options.dump_format = FLVMETA_FORMAT_XML;
options.verbose = 0;
options.metadata_event = NULL;
/* Command-line parsing */
errcode = parse_command_line(argc, argv, &options);
/* free metadata if necessary */
if ((errcode != OK || options.command != FLVMETA_UPDATE_COMMAND) && options.metadata != NULL) {
amf_data_free(options.metadata);
}
if (errcode == OK) {
/* execute command */
switch (options.command) {
case FLVMETA_DUMP_COMMAND: errcode = dump_metadata(&options); break;
case FLVMETA_FULL_DUMP_COMMAND: errcode = dump_flv_file(&options); break;
case FLVMETA_CHECK_COMMAND: errcode = check_flv_file(&options); break;
case FLVMETA_UPDATE_COMMAND: errcode = update_metadata(&options); break;
case FLVMETA_VERSION_COMMAND: version(); break;
case FLVMETA_HELP_COMMAND: help(argv[0]); break;
}
/* error report */
switch (errcode) {
case ERROR_OPEN_READ: fprintf(stderr, "%s: cannot open %s for reading\n", argv[0], options.input_file); break;
case ERROR_NO_FLV: fprintf(stderr, "%s: %s is not a valid FLV file\n", argv[0], options.input_file); break;
case ERROR_EOF: fprintf(stderr, "%s: unexpected end of file\n", argv[0]); break;
case ERROR_MEMORY: fprintf(stderr, "%s: memory allocation error\n", argv[0]); break;
case ERROR_EMPTY_TAG: fprintf(stderr, "%s: empty FLV tag\n", argv[0]); break;
case ERROR_OPEN_WRITE: fprintf(stderr, "%s: cannot open %s for writing\n", argv[0], options.output_file); break;
case ERROR_INVALID_TAG: fprintf(stderr, "%s: invalid FLV tag\n", argv[0]); break;
case ERROR_WRITE: fprintf(stderr, "%s: unable to write to %s\n", argv[0], options.output_file); break;
case ERROR_SAME_FILE: fprintf(stderr, "%s: input file and output file must be different\n", argv[0]); break;
}
}
return errcode;
}
void stream_encoders::update_metadata(metadb_handle_ptr p_track){
if(p_track!=0){
p_track->metadb_lock();
const file_info*p_info;
if(p_track->get_info_async_locked(p_info))
update_metadata(*p_info);
p_track->metadb_unlock();
}
}
static OMX_ERRORTYPE
obtain_next_url (dirble_prc_t * ap_prc, int a_skip_value)
{
OMX_ERRORTYPE rc = OMX_ErrorNone;
const long pathname_max = PATH_MAX + NAME_MAX;
assert (ap_prc);
assert (ap_prc->p_dirble_);
if (!ap_prc->p_uri_param_)
{
ap_prc->p_uri_param_ = tiz_mem_calloc (
1, sizeof (OMX_PARAM_CONTENTURITYPE) + pathname_max + 1);
}
tiz_check_null_ret_oom (ap_prc->p_uri_param_ != NULL);
ap_prc->p_uri_param_->nSize
= sizeof (OMX_PARAM_CONTENTURITYPE) + pathname_max + 1;
ap_prc->p_uri_param_->nVersion.nVersion = OMX_VERSION;
{
const char * p_next_url
= a_skip_value > 0 ? tiz_dirble_get_next_url (ap_prc->p_dirble_,
ap_prc->remove_current_url_)
: tiz_dirble_get_prev_url (
ap_prc->p_dirble_, ap_prc->remove_current_url_);
ap_prc->remove_current_url_ = false;
tiz_check_null_ret_oom (p_next_url != NULL);
{
const OMX_U32 url_len = strnlen (p_next_url, pathname_max);
TIZ_TRACE (handleOf (ap_prc), "URL [%s]", p_next_url);
/* Verify we are getting an http scheme */
if (!p_next_url || !url_len
|| (memcmp (p_next_url, "http://", 7) != 0
&& memcmp (p_next_url, "https://", 8) != 0))
{
rc = OMX_ErrorContentURIError;
}
else
{
strncpy ((char *) ap_prc->p_uri_param_->contentURI, p_next_url,
url_len);
ap_prc->p_uri_param_->contentURI[url_len] = '\000';
/* Song metadata is now available, update the IL client */
rc = update_metadata (ap_prc);
}
}
}
return rc;
}
PopulationSpace( boost::property_tree::ptree & config ) :
sequences( config )
, alleles( config )
{
create_space( free_space );
create_space( pheno_space );
// resize_space( free_space, allele_space_type::device_space_type::ALIGNMENT_SIZE );
update_metadata();
}
int get_docid(int docid, struct tobj* tobj)
{
struct tobj* t = tobj;
int block_num = t->block_num;
int ret = 0;
int maxid = t->maxid;
//printf("get docid\n");
while((t->cur_block + 1)<= block_num){
ret = check_meta_docid(docid, t);
if(ret != maxid)
return ret;
t->cur_block += 1;
if(t->cur_block + 1 > block_num)
break;
update_metadata(t->start_addr + t->cur_block * t->c_blocksize, t);
clear_chunk_access_flag(t);
t->cur_chunk = 0;
}
return maxid;
}
static int store_icy(URLContext *h, int size)
{
HTTPContext *s = h->priv_data;
/* until next metadata packet */
int remaining = s->icy_metaint - s->icy_data_read;
if (remaining < 0)
return AVERROR_INVALIDDATA;
if (!remaining) {
/* The metadata packet is variable sized. It has a 1 byte header
* which sets the length of the packet (divided by 16). If it's 0,
* the metadata doesn't change. After the packet, icy_metaint bytes
* of normal data follows. */
uint8_t ch;
int len = http_read_stream_all(h, &ch, 1);
if (len < 0)
return len;
if (ch > 0) {
char data[255 * 16 + 1];
int ret;
len = ch * 16;
ret = http_read_stream_all(h, data, len);
if (ret < 0)
return ret;
data[len + 1] = 0;
if ((ret = av_opt_set(s, "icy_metadata_packet", data, 0)) < 0)
return ret;
update_metadata(s, data);
}
s->icy_data_read = 0;
remaining = s->icy_metaint;
}
return FFMIN(size, remaining);
}
struct tobj* term_init(int* info)
{
int ret = 0;
struct tobj *t = NULL;
t = (struct tobj*)malloc(sizeof(struct tobj));
if(t == NULL)
return t;
t->tindex = term_num;
term_num += 1;
t->fileindex = info[0];
t->chunk_s = info[1];
t->chunk_e = info[2];
t->start_addr = info[3];
t->end_addr = info[4];
t->doc_num = info[5];
t->block_num = (info[4] - info[3])/config.c_blocksize;
t->c_blocksize = config.c_blocksize;
t->cur_block = 0;
t->cur_chunk = t->chunk_s;
t->cur_meta_l = 0;
t->flag = 0;
t->maxid = config.maxid;
file_open(t->fileindex);
/* update metadata */
ret = update_metadata(t->start_addr, t);
if(ret){
//printf("update metadata fail \n");
file_close(t->fileindex);
return NULL;
}
//printf("term init done %d s %d e %d \n", t->tindex, t->chunk_s, t->chunk_e);
return t;
}
int
film::process ()
{
int audioSize;
uint8_t *buffer;
uint8_t *buffer2;
int frameFinished;
int numBytes;
shot s;
static struct SwsContext *img_convert_ctx = NULL;
create_main_dir ();
string graphpath = this->global_path + "/";
g = new graph (600, 400, graphpath, threshold, this);
g->set_title ("Motion quantity");
/*
* Register all formats and codecs
*/
av_register_all ();
if (av_open_input_file (&pFormatCtx, input_path.c_str (), NULL, 0, NULL) != 0)
{
string error_msg = "Impossible to open file";
error_msg += input_path;
shotlog (error_msg);
return -1; // Couldn't open file
}
/*
* Retrieve stream information
*/
if (av_find_stream_info (pFormatCtx) < 0)
return -1; // Couldn't find stream information
// dump_format (pFormatCtx, 0, path.c_str (), false);
videoStream = -1;
audioStream = -1;
/*
* Detect streams types
*/
for (int j = 0; j < pFormatCtx->nb_streams; j++)
{
switch (pFormatCtx->streams[j]->codec->codec_type)
{
case AVMEDIA_TYPE_VIDEO:
videoStream = j;
break;
case AVMEDIA_TYPE_AUDIO:
audioStream = j;
break;
default:
break;
}
}
/*
* Get a pointer to the codec context for the video stream
*/
if (audioStream != -1)
{
if (audio_set)
{
string xml_audio = graphpath + "/" + "audio.xml";
init_xml (xml_audio);
}
pCodecCtxAudio = pFormatCtx->streams[audioStream]->codec;
pCodecAudio = avcodec_find_decoder (pCodecCtxAudio->codec_id);
if (pCodecAudio == NULL)
return -1; // Codec not found
if (avcodec_open (pCodecCtxAudio, pCodecAudio) < 0)
return -1; // Could not open codec
}
update_metadata ();
/*
* Find the decoder for the video stream
*/
if (videoStream != -1)
{
pCodecCtx = pFormatCtx->streams[videoStream]->codec;
pCodec = avcodec_find_decoder (pCodecCtx->codec_id);
if (pCodec == NULL)
return -1; // Codec not found
if (avcodec_open (pCodecCtx, pCodec) < 0)
return -1; // Could not open codec
/*
* Allocate video frame
*/
pFrame = avcodec_alloc_frame ();
pFrameRGB = avcodec_alloc_frame ();
pFrameRGBprev = avcodec_alloc_frame ();
/*
* Determine required buffer size and allocate buffer
*/
numBytes = avpicture_get_size (PIX_FMT_RGB24, width, height);
buffer = (uint8_t *) malloc (sizeof (uint8_t) * numBytes);
buffer2 = (uint8_t *) malloc (sizeof (uint8_t) * numBytes);
/*
* Assign appropriate parts of buffer to image planes in pFrameRGB
*/
avpicture_fill ((AVPicture *) pFrameRGB, buffer, PIX_FMT_RGB24, width, height);
avpicture_fill ((AVPicture *) pFrameRGBprev, buffer2, PIX_FMT_RGB24, width, height);
/*
* Mise en place du premier plan
*/
s.fbegin = 0;
s.msbegin = 0;
s.myid = 0;
shots.push_back (s);
}
checknumber = (samplerate * samplearg) / 1000;
/*
* Boucle de traitement principale du flux
*/
this->frame_number = 0;
while (av_read_frame (pFormatCtx, &packet) >= 0)
{
if (packet.stream_index == videoStream)
{
AVPacket pkt;
av_init_packet (&pkt);
pkt.data = packet.data;
pkt.size = packet.size;
avcodec_decode_video2 (pCodecCtx, pFrame, &frameFinished, &pkt);
if (frameFinished)
{
// Convert the image into RGB24
if (! img_convert_ctx)
{
img_convert_ctx = sws_getContext(width, height, pCodecCtx->pix_fmt,
width, height, PIX_FMT_RGB24, SWS_BICUBIC,
NULL, NULL, NULL);
if (! img_convert_ctx)
{
fprintf(stderr, "Cannot initialize the conversion context!\n");
exit(1);
}
}
/* API: int sws_scale(SwsContext *c, uint8_t *src, int srcStride[], int srcSliceY, int srcSliceH, uint8_t dst[], int dstStride[] )
*/
sws_scale(img_convert_ctx, pFrame->data,
pFrame->linesize, 0,
pCodecCtx->height,
pFrameRGB->data, pFrameRGB->linesize);
/*
Old API doc (cf http://www.dranger.com/ffmpeg/functions.html )
int img_convert(AVPicture *dst, int dst_pix_fmt,
const AVPicture *src, int src_pix_fmt,
int src_width, int src_height)
*/
/*
img_convert ((AVPicture *) pFrameRGB, PIX_FMT_RGB24, (AVPicture *) pFrame, pCodecCtx->pix_fmt, width, height);
*/
this->frame_number ++;
/* Si ce n'est pas la permiere image */
if ( this->frame_number > 2)
{
CompareFrame (pFrameRGB, pFrameRGBprev);
}
else
{
/*
* Cas ou c'est la premiere image, on cree la premiere image dans tous les cas
*/
image *begin_i = new image (this, width, height, s.myid, BEGIN);
begin_i->create_img_dir ();
begin_i->SaveFrame (pFrameRGB);
shots.back ().img_begin = begin_i;
}
memcpy (buffer2, buffer, numBytes);
}
}
if (audio_set && (packet.stream_index == audioStream))
{
process_audio ();
}
/*
* Free the packet that was allocated by av_read_frame
*/
if (packet.data != NULL)
av_free_packet (&packet);
}
if (videoStream != -1)
{
/* Mise en place de la dernière image */
int lastFrame = this->frame_number;
shots.back ().fduration = lastFrame - shots.back ().fbegin;
shots.back ().msduration = int (((shots.back ().fduration) * 1000) / fps);
duration.mstotal = int (shots.back ().msduration + shots.back ().msbegin);
image *end_i = new image (this, width, height, shots.back ().myid, END);
end_i->SaveFrame (pFrameRGB);
shots.back ().img_end = end_i;
/*
* Graphe de la qté de mvmt
*/
g->init_gd ();
g->draw_all_canvas ();
g->draw_color_datas ();
g->draw_datas ();
if (video_set)
{
string xml_color = graphpath + "/" + "video.xml";
g->write_xml (xml_color);
}
g->save ();
/*
* Free the RGB images
*/
free (buffer);
free (buffer2);
av_free (pFrameRGB);
av_free (pFrame);
av_free (pFrameRGBprev);
avcodec_close (pCodecCtx);
}
/*
* Close the codec
*/
if (audioStream != -1)
{
/* Fermetrure du fichier xml */
if (audio_set) close_xml ();
avcodec_close (pCodecCtxAudio);
}
/*
* Close the video file
*/
av_close_input_file (pFormatCtx);
}
/**
* @brief Camera sensor Capabilities
* @param size buffer size
* @param capabilities buffer address
* @return zero for success or non-zero on any faillure
*/
int get_capabilities(uint32_t *size, uint8_t *capabilities)
{
struct camera_metadata_package *metadata_ptr;
uint8_t *cap;
int index = 0, buffercount = 0, ret;
const uint8_t availableAntibandingModes[] = {
CONTROL_AE_ANTIBANDING_MODE_OFF,
CONTROL_AE_ANTIBANDING_MODE_50HZ,
CONTROL_AE_ANTIBANDING_MODE_60HZ,
CONTROL_AE_ANTIBANDING_MODE_AUTO
};
const uint8_t availableAeModes[] = {
CONTROL_AE_MODE_OFF,
CONTROL_AE_MODE_ON,
CONTROL_AE_MODE_ON_AUTO_FLASH,
CONTROL_AE_MODE_ON_ALWAYS_FLASH,
CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE
};
const int32_t availableTargetFpsRanges[] = {5, 30, 15, 30};
const int32_t exposureCompensationRange[] = {-9, 9};
const camera_metadata_rational_t exposureCompensationStep = {1, 3};
const uint8_t availableAfModesBack[] = {
CONTROL_AF_MODE_OFF,
CONTROL_AF_MODE_AUTO,
CONTROL_AF_MODE_MACRO,
CONTROL_AF_MODE_CONTINUOUS_VIDEO,
CONTROL_AF_MODE_CONTINUOUS_PICTURE
};
const uint8_t availableSceneModes[] = {
CONTROL_SCENE_MODE_DISABLED,
CONTROL_SCENE_MODE_FACE_PRIORITY,
CONTROL_SCENE_MODE_ACTION,
CONTROL_SCENE_MODE_PORTRAIT,
CONTROL_SCENE_MODE_LANDSCAPE,
CONTROL_SCENE_MODE_NIGHT,
CONTROL_SCENE_MODE_NIGHT_PORTRAIT,
CONTROL_SCENE_MODE_THEATRE,
CONTROL_SCENE_MODE_BEACH,
CONTROL_SCENE_MODE_SNOW,
CONTROL_SCENE_MODE_SUNSET,
CONTROL_SCENE_MODE_STEADYPHOTO,
CONTROL_SCENE_MODE_FIREWORKS,
CONTROL_SCENE_MODE_SPORTS,
CONTROL_SCENE_MODE_PARTY,
CONTROL_SCENE_MODE_CANDLELIGHT,
CONTROL_SCENE_MODE_BARCODE,
CONTROL_SCENE_MODE_HIGH_SPEED_VIDEO,
CONTROL_SCENE_MODE_HDR
};
const uint8_t availableVstabModes[] = {
CONTROL_VIDEO_STABILIZATION_MODE_OFF,
CONTROL_VIDEO_STABILIZATION_MODE_ON
};
const uint8_t availableAwbModes[] = {
CONTROL_AWB_MODE_OFF,
CONTROL_AWB_MODE_AUTO,
CONTROL_AWB_MODE_INCANDESCENT,
CONTROL_AWB_MODE_FLUORESCENT,
CONTROL_AWB_MODE_WARM_FLUORESCENT,
CONTROL_AWB_MODE_DAYLIGHT,
CONTROL_AWB_MODE_CLOUDY_DAYLIGHT,
CONTROL_AWB_MODE_TWILIGHT,
CONTROL_AWB_MODE_SHADE,
};
const int32_t max3aRegions[] = {0, 0, 0};
const uint8_t flashAvailable = FLASH_INFO_AVAILABLE_FALSE;
const int32_t jpegThumbnailSizes[] = {0, 0, 160, 120, 320, 240};
const float focalLength = 2.50f;
const int32_t max_output_streams[] = {
MAX_STALLING_STREAMS,
MAX_PROCESSED_STREAMS,
MAX_RAW_STREAMS
};
const int32_t scalar_formats[] = {
SCALER_AVAILABLE_FORMATS_RAW16,
SCALER_AVAILABLE_FORMATS_RAW_OPAQUE,
SCALER_AVAILABLE_FORMATS_YV12,
SCALER_AVAILABLE_FORMATS_YCrCb_420_SP,
SCALER_AVAILABLE_FORMATS_IMPLEMENTATION_DEFINED,
SCALER_AVAILABLE_FORMATS_YCbCr_420_888,
SCALER_AVAILABLE_FORMATS_BLOB
};
const float maxZoom = 10.0f;
const int32_t orientation = 0;
const int32_t SensitivityRange[2] = {100, 1600};
const float sensorPhysicalSize[2] = {3.20f, 2.40f};
const int32_t Resolution[] = {640, 480};
const int32_t maxFaceCount = 8;
/* buffer initial */
cap = capabilities;
metadata_ptr = zalloc(sizeof(struct camera_metadata_package));
if (!metadata_ptr)
return -ENOMEM;
metadata_ptr->entries = zalloc(MAX_METADATA_NUMBER *
sizeof(struct camera_metadata_entry));
if (!metadata_ptr->entries) {
goto err_free_metadata_ptr;
}
/* need to modify it */
metadata_ptr->data = zalloc(MAX_METADATA_NUMBER * MAX_METADATA_SIZE);
if (!metadata_ptr->data ) {
goto err_free_metadata;
}
metadata_ptr->header.version = ARA_METADATA_VERSION;
/* CONTROL_AE_AVAILABLE_ANTIBANDING_MODES */
ret = update_metadata(metadata_ptr, TYPE_BYTE,
CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
sizeof(availableAntibandingModes),
availableAntibandingModes);
if (ret) {
goto err_free_all;
}
/* CONTROL_AE_AVAILABLE_MODES */
ret = update_metadata(metadata_ptr, TYPE_BYTE, CONTROL_AE_AVAILABLE_MODES,
sizeof(availableAeModes), availableAeModes);
if (ret) {
goto err_free_all;
}
/* CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES */
ret = update_metadata(metadata_ptr, TYPE_INT32,
CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
sizeof(availableTargetFpsRanges),
(uint8_t *)availableTargetFpsRanges);
if (ret) {
goto err_free_all;
}
/* CONTROL_AE_COMPENSATION_STEP */
ret = update_metadata(metadata_ptr, TYPE_INT32,
CONTROL_AE_COMPENSATION_RANGE,
sizeof(exposureCompensationRange),
(uint8_t *)exposureCompensationRange);
if (ret) {
goto err_free_all;
}
/* CONTROL_AE_COMPENSATION_STEP */
ret = update_metadata(metadata_ptr, TYPE_RATIONAL,
CONTROL_AE_COMPENSATION_STEP,
sizeof(exposureCompensationStep),
(uint8_t *)&exposureCompensationStep);
if (ret) {
goto err_free_all;
}
/* CONTROL_AF_AVAILABLE_MODES */
ret = update_metadata(metadata_ptr, TYPE_BYTE, CONTROL_AF_AVAILABLE_MODES,
sizeof(availableAfModesBack), availableAfModesBack);
if (ret) {
goto err_free_all;
}
/* CONTROL_AVAILABLE_SCENE_MODES */
ret = update_metadata(metadata_ptr, TYPE_BYTE,
CONTROL_AVAILABLE_SCENE_MODES,
sizeof(availableSceneModes), availableSceneModes);
if (ret) {
goto err_free_all;
}
/* CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES */
ret = update_metadata(metadata_ptr, TYPE_BYTE,
CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
sizeof(availableVstabModes), availableVstabModes);
if (ret) {
goto err_free_all;
}
/* CONTROL_AWB_AVAILABLE_MODES */
ret = update_metadata(metadata_ptr, TYPE_BYTE, CONTROL_AWB_AVAILABLE_MODES,
sizeof(availableAwbModes), availableAwbModes);
if (ret) {
goto err_free_all;
}
/* CONTROL_MAX_REGIONS */
ret = update_metadata(metadata_ptr, TYPE_BYTE, CONTROL_MAX_REGIONS,
sizeof(max3aRegions), (uint8_t *)max3aRegions);
if (ret) {
goto err_free_all;
}
/* CONTROL_SCENE_MODES_OVERRIDES */
/* FLASH_INFO_AVAILABLE */
ret = update_metadata(metadata_ptr, TYPE_BYTE, FLASH_INFO_AVAILABLE,
sizeof(flashAvailable), &flashAvailable);
if (ret) {
goto err_free_all;
}
/* JPEG_AVAILABLE_THUMBNAIL_SIZES */
ret = update_metadata(metadata_ptr, TYPE_INT32,
JPEG_AVAILABLE_THUMBNAIL_SIZES,
sizeof(jpegThumbnailSizes),
(uint8_t *)jpegThumbnailSizes);
if (ret) {
goto err_free_all;
}
/* LENS_INFO_AVAILABLE_FOCAL_LENGTHS */
ret = update_metadata(metadata_ptr, TYPE_FLOAT,
LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
sizeof(focalLength), (uint8_t *)&focalLength);
if (ret) {
goto err_free_all;
}
/* REQUEST_MAX_NUM_OUTPUT_STREAMS */
ret = update_metadata(metadata_ptr, TYPE_INT32,
REQUEST_MAX_NUM_OUTPUT_STREAMS,
sizeof(max_output_streams),
(uint8_t *)max_output_streams);
if (ret) {
goto err_free_all;
}
/* REQUEST_AVAILABLE_REQUEST_KEYS = 0x68 */
/* REQUEST_AVALIABLE_RESULT_KEYS */
/* REQUEST_AVALIABLE_CHARACTERISTICS */
/* SCALER_AVAILABLE_FORMATS */
ret = update_metadata(metadata_ptr, TYPE_INT32, SCALER_AVAILABLE_FORMATS,
sizeof(scalar_formats), (uint8_t *)scalar_formats);
if (ret) {
goto err_free_all;
}
/* SCALER_AVAILABLE_MAX_DIGITAL_ZOOM */
ret = update_metadata(metadata_ptr, TYPE_FLOAT,
SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
sizeof(maxZoom), (uint8_t *)&maxZoom);
if (ret) {
goto err_free_all;
}
/* SENSOR_ORIENTATION */
ret = update_metadata(metadata_ptr, TYPE_INT32, SENSOR_ORIENTATION,
sizeof(orientation), (uint8_t *)&orientation);
if (ret) {
goto err_free_all;
}
/* SENSOR_INFO_SENSITIVITY_RANGE */
ret = update_metadata(metadata_ptr, TYPE_INT32,
SENSOR_INFO_SENSITIVITY_RANGE,
sizeof(SensitivityRange),
(uint8_t *)SensitivityRange);
if (ret) {
goto err_free_all;
}
/* SENSOR_INFO_PHYSICAL_SIZE */
ret = update_metadata(metadata_ptr, TYPE_FLOAT, SENSOR_INFO_PHYSICAL_SIZE,
sizeof(sensorPhysicalSize),
(uint8_t *)sensorPhysicalSize);
if (ret) {
goto err_free_all;
}
/* SENSOR_INFO_PIXEL_ARRAY_SIZE */
ret = update_metadata(metadata_ptr, TYPE_INT32,
SENSOR_INFO_PIXEL_ARRAY_SIZE,
sizeof(Resolution), (uint8_t *)Resolution);
if (ret) {
goto err_free_all;
}
/* STATISTICS_INFO_MAX_FACE_COUNT */
ret = update_metadata(metadata_ptr, TYPE_INT32,
STATISTICS_INFO_MAX_FACE_COUNT,
sizeof(maxFaceCount), (uint8_t *)&maxFaceCount);
if (ret) {
goto err_free_all;
}
/* Do the Data Copy */
memcpy(cap, &metadata_ptr->header, sizeof(metadata_ptr->header));
buffercount = sizeof(metadata_ptr->header);
metadata_ptr->header.entry_start = buffercount;
cap += buffercount;
for (index = 0; index < metadata_ptr->header.entry_count; index++) {
memcpy(cap, &metadata_ptr->entries[index],
sizeof(metadata_ptr->entries[0]));
buffercount += sizeof(metadata_ptr->entries[0]);
cap += sizeof(metadata_ptr->entries[0]);
}
metadata_ptr->header.metadata_data_start = buffercount;
memcpy(cap, &metadata_ptr->data[0], metadata_ptr->header.size);
/* total size of metadata package size */
buffercount += metadata_ptr->header.size;
metadata_ptr->header.size = buffercount;
*size = buffercount;
metadata_ptr->header.metadata_data_count =
metadata_ptr->header.entry_count;
free(metadata_ptr->data);
free(metadata_ptr->entries);
free(metadata_ptr);
return 0;
err_free_all:
free(metadata_ptr->data);
err_free_metadata:
free(metadata_ptr->entries);
err_free_metadata_ptr:
free(metadata_ptr);
return -ENOMEM;
}
/**
* @brief Camera sensor capture result metadata
* @param size buffer size
* @param capabilities buffer address
* @return zero for success or non-zero on any faillure
*/
int get_capture_results_metadata(uint32_t *size, uint8_t *capabilities)
{
struct camera_metadata_package *metadata_ptr;
uint8_t *cap;
int index = 0, buffercount = 0, ret;
const float focalLength = 2.50f;
const float focusDistance = 0;
/* buffer initial */
cap = capabilities;
metadata_ptr = zalloc(sizeof(struct camera_metadata_package));
if (!metadata_ptr)
return -ENOMEM;
metadata_ptr->entries = zalloc(MAX_METADATA_NUMBER *
sizeof(struct camera_metadata_entry));
if (!metadata_ptr->entries) {
free(metadata_ptr);
goto err_free_metadata_ptr;
}
metadata_ptr->data = zalloc(MAX_METADATA_NUMBER * MAX_METADATA_SIZE);
if (!metadata_ptr->data ) {
goto err_free_metadata;
}
metadata_ptr->header.version = ARA_METADATA_VERSION;
/* LENS_FOCUS_RANGE */
/* SENSOR_TIMESTAMP */
/* STATISTICS_FACE_IDS */
/* STATISTICS_FACE_LANDMARKS */
/* STATISTICS_FACE_RECTANGLES */
/* STATISTICS_FACE_SCORES */
/* LENS_INFO_AVAILABLE_FOCAL_LENGTHS */
ret = update_metadata(metadata_ptr, TYPE_FLOAT,
LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
sizeof(focalLength), (uint8_t *)&focalLength);
if (ret) {
goto err_free_all;
}
/* LENS_FOCUS_DISTANCE */
ret = update_metadata(metadata_ptr, TYPE_FLOAT, LENS_FOCUS_DISTANCE,
sizeof(focusDistance), (uint8_t *)&focusDistance);
if (ret) {
goto err_free_all;
}
/* Do the Data Copy */
memcpy(cap, &metadata_ptr->header, sizeof(metadata_ptr->header));
buffercount = sizeof(metadata_ptr->header);
metadata_ptr->header.entry_start = buffercount;
cap += buffercount;
for (index = 0; index < metadata_ptr->header.entry_count; index++) {
memcpy(cap, &metadata_ptr->entries[index],
sizeof(metadata_ptr->entries[0]));
buffercount += sizeof(metadata_ptr->entries[0]);
cap += sizeof(metadata_ptr->entries[0]);
}
metadata_ptr->header.metadata_data_start = buffercount;
memcpy(cap, &metadata_ptr->data[0], metadata_ptr->header.size);
/* total size of metadata package size */
buffercount += metadata_ptr->header.size;
metadata_ptr->header.size = buffercount;
*size = buffercount;
metadata_ptr->header.metadata_data_count =
metadata_ptr->header.entry_count;
free(metadata_ptr->data);
free(metadata_ptr->entries);
free(metadata_ptr);
return 0;
err_free_all:
free(metadata_ptr->data);
err_free_metadata:
free(metadata_ptr->entries);
err_free_metadata_ptr:
free(metadata_ptr);
return -ENOMEM;
}
void
cb_get_object(void *handle)
{
dpl_async_task_t *atask = (dpl_async_task_t *) handle;
int i;
dpl_dict_var_t *metadatum = NULL;
if (DPL_SUCCESS != atask->ret)
{
fprintf(stderr, "dpl_get failed: %s (%d)\n", dpl_status_str(atask->ret), atask->ret);
exit(1);
}
fprintf(stderr, "checking object\n");
if (DATA_LEN != atask->u.get.buf->size)
{
fprintf(stderr, "data lengths mismatch\n");
exit(1);
}
for (i = 0;i < DATA_LEN;i++)
if (atask->u.get.buf->ptr[i] != 'z')
{
fprintf(stderr, "data content mismatch\n");
exit(1);
}
fprintf(stderr, "checking metadata\n");
metadatum = dpl_dict_get(atask->u.get.metadata, "foo");
if (NULL == metadatum)
{
fprintf(stderr, "missing metadatum\n");
exit(1);
}
assert(metadatum->val->type == DPL_VALUE_STRING);
if (strcmp(dpl_sbuf_get_str(metadatum->val->string), "bar"))
{
fprintf(stderr, "bad value in metadatum\n");
exit(1);
}
metadatum = dpl_dict_get(atask->u.get.metadata, "foo2");
if (NULL == metadatum)
{
fprintf(stderr, "missing metadatum\n");
exit(1);
}
assert(metadatum->val->type == DPL_VALUE_STRING);
if (strcmp(dpl_sbuf_get_str(metadatum->val->string), "qux"))
{
fprintf(stderr, "bad value in metadatum\n");
exit(1);
}
dpl_async_task_free(atask);
update_metadata();
}
static void update_image (void * data, GObject * object)
{
recheck_image = TRUE;
update_metadata (data, object);
}
int frame_parse::parse_mpeg4_frame ( OMX_BUFFERHEADERTYPE *source,
OMX_BUFFERHEADERTYPE *dest ,
OMX_U32 *partialframe)
{
OMX_U8 *pdest = NULL,*psource = NULL;
OMX_U32 dest_len =0, source_len = 0, temp_len = 0;
OMX_U32 parsed_length = 0,i=0;
int residue_byte = 0;
if (source == NULL || dest == NULL || partialframe == NULL)
{
return -1;
}
/*Calculate how many bytes are left in source and destination*/
dest_len = dest->nAllocLen - (dest->nFilledLen + dest->nOffset);
psource = source->pBuffer + source->nOffset;
pdest = dest->pBuffer + (dest->nFilledLen + dest->nOffset);
source_len = source->nFilledLen;
/*Need Minimum of 4 for destination to copy atleast Start code*/
if (dest_len < 4 || source_len == 0)
{
DEBUG_PRINT_LOW("\n Dest_len %d source_len %d",dest_len,source_len);
if (source_len == 0 && (source->nFlags & 0x01))
{
DEBUG_PRINT_LOW("\n EOS condition Inform Client that it is complete frame");
*partialframe = 0;
return 1;
}
DEBUG_PRINT_LOW("\n Error in Parsing bitstream");
return -1;
}
/*Check if State of the previous find is a Start code*/
if (parse_state == A4)
{
/*Check for minimun size should be 4*/
dest->nFlags = flags;
dest->nTimeStamp = time_stamp;
update_metadata(source->nTimeStamp,source->nFlags);
memcpy (pdest,start_code,4);
pdest [2] = prev_one;
pdest [3] = last_byte;
dest->nFilledLen += 4;
pdest += 4;
parse_state = A0;
}
/*Entry State Machine*/
while ( source->nFilledLen > 0 && parse_state != A0
&& parse_state != A4 && dest_len > 0
)
{
//printf ("\n In the Entry Loop");
switch (parse_state)
{
case A3:
/*If fourth Byte is matching then start code is found*/
if ((*psource & mask_code [3]) == start_code [3])
{
last_byte = *psource;
parse_state = A4;
source->nFilledLen--;
source->nOffset++;
psource++;
}
else if ((start_code [1] == start_code [0]) && (start_code [2] == start_code [1]))
{
parse_state = A2;
memcpy (pdest,start_code,1);
pdest++;
dest->nFilledLen++;
dest_len--;
}
else if (start_code [2] == start_code [0])
{
parse_state = A1;
memcpy (pdest,start_code,2);
pdest += 2;
dest->nFilledLen += 2;
dest_len -= 2;
}
else
{
parse_state = A0;
memcpy (pdest,start_code,3);
pdest += 3;
dest->nFilledLen +=3;
dest_len -= 3;
}
break;
case A2:
if ((*psource & mask_code [2]) == start_code [2])
{
prev_one = *psource;
parse_state = A3;
source->nFilledLen--;
source->nOffset++;
psource++;
}
else if ( start_code [1] == start_code [0])
{
parse_state = A1;
memcpy (pdest,start_code,1);
dest->nFilledLen +=1;
dest_len--;
pdest++;
}
else
{
parse_state = A0;
memcpy (pdest,start_code,2);
dest->nFilledLen +=2;
dest_len -= 2;
pdest += 2;
}
break;
case A1:
if ((*psource & mask_code [1]) == start_code [1])
{
parse_state = A2;
source->nFilledLen--;
source->nOffset++;
psource++;
}
else
{
memcpy (pdest,start_code,1);
dest->nFilledLen +=1;
pdest++;
dest_len--;
parse_state = A0;
}
break;
case A4:
case A0:
break;
}
dest_len = dest->nAllocLen - (dest->nFilledLen + dest->nOffset);
}
if (parse_state == A4)
{
*partialframe = 0;
DEBUG_PRINT_LOW("\n Nal Found length is %d",dest->nFilledLen);
return 1;
}
/*Partial Frame is true*/
*partialframe = 1;
/*Calculate how many bytes are left in source and destination*/
dest_len = dest->nAllocLen - (dest->nFilledLen + dest->nOffset);
psource = source->pBuffer + source->nOffset;
pdest = dest->pBuffer + (dest->nFilledLen + dest->nOffset);
source_len = source->nFilledLen;
temp_len = (source_len < dest_len)?source_len:dest_len;
/*Check if entry state machine consumed source or destination*/
if (temp_len == 0)
{
return 1;
}
/*Parsing State Machine*/
while (parsed_length < temp_len)
{
switch (parse_state)
{
case A0:
if ((psource [parsed_length] & mask_code [0]) == start_code[0])
{
parse_state = A1;
}
parsed_length++;
break;
case A1:
if ((psource [parsed_length] & mask_code [1]) == start_code [1])
{
parsed_length++;
parse_state = A2;
}
else
{
parse_state = A0;
}
break;
case A2:
if ((psource [parsed_length] & mask_code [2]) == start_code [2])
{
prev_one = psource [parsed_length];
parsed_length++;
parse_state = A3;
}
else if (start_code [1] == start_code [0])
{
parse_state = A1;
}
else
{
parse_state = A0;
}
break;
case A3:
if ((psource [parsed_length] & mask_code [3]) == start_code [3])
{
last_byte = psource [parsed_length];
parsed_length++;
parse_state = A4;
}
else if ((start_code [1] == start_code [0]) && (start_code [2] == start_code [1]))
{
parse_state = A2;
}
else if (start_code [2] == start_code [0])
{
parse_state = A1;
}
else
{
parse_state = A0;
}
break;
default:
break;
}
/*Found the code break*/
if (parse_state == A4)
{
break;
}
}
/*Exit State Machine*/
psource = source->pBuffer + source->nOffset;
switch (parse_state)
{
case A4:
*partialframe = 0;
if (parsed_length > 4)
{
memcpy (pdest,psource,(parsed_length-4));
dest->nFilledLen += (parsed_length-4);
}
break;
case A3:
if (parsed_length > 3)
{
memcpy (pdest,psource,(parsed_length-3));
dest->nFilledLen += (parsed_length-3);
}
break;
case A2:
if (parsed_length > 2)
{
memcpy (pdest,psource,(parsed_length-2));
dest->nFilledLen += (parsed_length-2);
}
break;
case A1:
if (parsed_length > 1)
{
memcpy (pdest,psource,(parsed_length-1));
dest->nFilledLen += (parsed_length-1);
}
break;
case A0:
memcpy (pdest,psource,(parsed_length));
dest->nFilledLen += (parsed_length);
break;
}
if (source->nFilledLen < parsed_length)
{
printf ("\n FATAL Error");
return -1;
}
source->nFilledLen -= parsed_length;
source->nOffset += parsed_length;
return 1;
}
