16 */ |
16 */ |
17 |
17 |
18 #include <stdio.h> |
18 #include <stdio.h> |
19 #include <stdlib.h> |
19 #include <stdlib.h> |
20 #include <string.h> |
20 #include <string.h> |
21 #include <assert.h> |
|
22 |
21 |
23 #include "xametadataextractionitf.h" |
22 #include "xametadataextractionitf.h" |
24 #include "xadebug.h" |
23 #include "xadebug.h" |
25 |
|
26 #include "xametadataadaptation.h" |
|
27 |
|
28 #include "xaadaptationmmf.h" |
24 #include "xaadaptationmmf.h" |
29 #include "xametadataadaptctxmmf.h" |
25 #include "xametadataadaptctxmmf.h" |
30 #include "xamediaplayeradaptctxmmf.h" |
26 #include "xamediaplayeradaptctxmmf.h" |
31 #include "cmetadatautilityitf.h" |
27 #include "cmetadatautilityitf.h" |
32 |
28 |
142 XAresult XAMetadataExtractionItfImpl_GetKeySize(XAMetadataExtractionItf self, |
130 XAresult XAMetadataExtractionItfImpl_GetKeySize(XAMetadataExtractionItf self, |
143 XAuint32 index, XAuint32 *pKeySize) |
131 XAuint32 index, XAuint32 *pKeySize) |
144 { |
132 { |
145 XAMetadataExtractionItfImpl *impl = NULL; |
133 XAMetadataExtractionItfImpl *impl = NULL; |
146 XAresult res = XA_RESULT_SUCCESS; |
134 XAresult res = XA_RESULT_SUCCESS; |
147 XAuint32 newidx = 0; |
135 |
148 DEBUG_API("->XAMetadataExtractionItfImpl_GetKeySize"); |
136 DEBUG_API("->XAMetadataExtractionItfImpl_GetKeySize"); |
149 |
137 |
150 impl = GetImpl(self); |
138 impl = GetImpl(self); |
151 if (!impl || !pKeySize) |
139 if (!impl || !pKeySize) |
152 { |
140 { |
169 res = XA_RESULT_PARAMETER_INVALID; |
157 res = XA_RESULT_PARAMETER_INVALID; |
170 } |
158 } |
171 } |
159 } |
172 else |
160 else |
173 { |
161 { |
174 /* check index and return unfiltered index */ |
162 res = XA_RESULT_PARAMETER_INVALID; |
175 if (CheckAndUnfilterIndex(impl, index, &newidx) != XA_RESULT_SUCCESS) |
|
176 { |
|
177 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
178 DEBUG_API("<-XAMetadataExtractionItfImpl_GetKeySize"); |
|
179 return XA_RESULT_PARAMETER_INVALID; |
|
180 } |
|
181 |
|
182 /* size = size of struct + size of data - 1 (struct size already includes one char) */ |
|
183 *pKeySize = sizeof(XAMetadataInfo) |
|
184 + impl->currentTags.mdeKeys[newidx]->size - 1; |
|
185 } |
163 } |
186 |
164 |
187 DEBUG_API_A1("<-XAMetadataExtractionItfImpl_GetKeySize (%d)", (int)res); |
165 DEBUG_API_A1("<-XAMetadataExtractionItfImpl_GetKeySize (%d)", (int)res); |
188 return res; |
166 return res; |
189 } |
167 } |
200 XAresult XAMetadataExtractionItfImpl_GetKey(XAMetadataExtractionItf self, |
178 XAresult XAMetadataExtractionItfImpl_GetKey(XAMetadataExtractionItf self, |
201 XAuint32 index, XAuint32 keySize, XAMetadataInfo *pKey) |
179 XAuint32 index, XAuint32 keySize, XAMetadataInfo *pKey) |
202 { |
180 { |
203 XAMetadataExtractionItfImpl *impl = NULL; |
181 XAMetadataExtractionItfImpl *impl = NULL; |
204 XAresult res = XA_RESULT_SUCCESS; |
182 XAresult res = XA_RESULT_SUCCESS; |
205 XAuint32 newidx = 0; |
183 |
206 |
|
207 XAuint32 neededsize = 0; |
|
208 |
|
209 XAuint32 newdatasize = 0; |
|
210 DEBUG_API("->XAMetadataExtractionItfImpl_GetKey"); |
184 DEBUG_API("->XAMetadataExtractionItfImpl_GetKey"); |
211 |
185 |
212 impl = GetImpl(self); |
186 impl = GetImpl(self); |
213 if (!impl || !pKey) |
187 if (!impl || !pKey) |
214 { |
188 { |
232 res = XA_RESULT_PARAMETER_INVALID; |
206 res = XA_RESULT_PARAMETER_INVALID; |
233 } |
207 } |
234 } |
208 } |
235 else |
209 else |
236 { |
210 { |
237 |
211 res = XA_RESULT_PARAMETER_INVALID; |
238 /* check index and return unfiltered index */ |
|
239 if (CheckAndUnfilterIndex(impl, index, &newidx) != XA_RESULT_SUCCESS) |
|
240 { |
|
241 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
242 DEBUG_API("<-XAMetadataExtractionItfImpl_GetKey"); |
|
243 return XA_RESULT_PARAMETER_INVALID; |
|
244 } |
|
245 |
|
246 /* needed size = size of struct + size of data - 1 (struct size already includes one char) */ |
|
247 neededsize = sizeof(XAMetadataInfo) |
|
248 + impl->currentTags.mdeKeys[newidx]->size - 1; |
|
249 if (keySize < neededsize) |
|
250 { /* cannot fit all of key data */ |
|
251 newdatasize = impl->currentTags.mdeKeys[newidx]->size |
|
252 - (neededsize - keySize); |
|
253 DEBUG_ERR("XA_RESULT_BUFFER_INSUFFICIENT"); |
|
254 res = XA_RESULT_BUFFER_INSUFFICIENT; |
|
255 } |
|
256 else |
|
257 { |
|
258 newdatasize = impl->currentTags.mdeKeys[newidx]->size; |
|
259 res = XA_RESULT_SUCCESS; |
|
260 } |
|
261 /* copy data up to given size */ |
|
262 memcpy(pKey, impl->currentTags.mdeKeys[newidx], keySize - 1); |
|
263 /* ensure null-termination */ |
|
264 |
|
265 memset(pKey->data + newdatasize - 1, 0, 1); |
|
266 pKey->size = newdatasize; |
|
267 } |
212 } |
268 |
213 |
269 DEBUG_API_A1("<-XAMetadataExtractionItfImpl_GetKey (%d)", (int)res); |
214 DEBUG_API_A1("<-XAMetadataExtractionItfImpl_GetKey (%d)", (int)res); |
270 return res; |
215 return res; |
271 } |
216 } |
280 XAresult XAMetadataExtractionItfImpl_GetValueSize( |
225 XAresult XAMetadataExtractionItfImpl_GetValueSize( |
281 XAMetadataExtractionItf self, XAuint32 index, XAuint32 *pValueSize) |
226 XAMetadataExtractionItf self, XAuint32 index, XAuint32 *pValueSize) |
282 { |
227 { |
283 XAMetadataExtractionItfImpl *impl = NULL; |
228 XAMetadataExtractionItfImpl *impl = NULL; |
284 XAresult res = XA_RESULT_SUCCESS; |
229 XAresult res = XA_RESULT_SUCCESS; |
285 XAuint32 newidx = 0; |
230 |
286 DEBUG_API("->XAMetadataExtractionItfImpl_GetValueSize"); |
231 DEBUG_API("->XAMetadataExtractionItfImpl_GetValueSize"); |
287 |
232 |
288 impl = GetImpl(self); |
233 impl = GetImpl(self); |
289 if (!impl || !pValueSize) |
234 if (!impl || !pValueSize) |
290 { |
235 { |
307 res = XA_RESULT_PARAMETER_INVALID; |
252 res = XA_RESULT_PARAMETER_INVALID; |
308 } |
253 } |
309 } |
254 } |
310 else |
255 else |
311 { |
256 { |
312 /* check index and return unfiltered index */ |
257 res = XA_RESULT_PARAMETER_INVALID; |
313 if (CheckAndUnfilterIndex(impl, index, &newidx) != XA_RESULT_SUCCESS) |
|
314 { |
|
315 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
316 DEBUG_API("<-XAMetadataExtractionItfImpl_GetValueSize"); |
|
317 return XA_RESULT_PARAMETER_INVALID; |
|
318 } |
|
319 |
|
320 /* size = size of struct + size of data - 1 (struct size already includes one char) */ |
|
321 *pValueSize = sizeof(XAMetadataInfo) |
|
322 + impl->currentTags.mdeValues[newidx]->size - 1; |
|
323 } |
258 } |
324 |
259 |
325 DEBUG_API_A1("<-XAMetadataExtractionItfImpl_GetValueSize (%d)", (int)res); |
260 DEBUG_API_A1("<-XAMetadataExtractionItfImpl_GetValueSize (%d)", (int)res); |
326 return res; |
261 return res; |
327 } |
262 } |
338 XAresult XAMetadataExtractionItfImpl_GetValue(XAMetadataExtractionItf self, |
273 XAresult XAMetadataExtractionItfImpl_GetValue(XAMetadataExtractionItf self, |
339 XAuint32 index, XAuint32 valueSize, XAMetadataInfo *pValue) |
274 XAuint32 index, XAuint32 valueSize, XAMetadataInfo *pValue) |
340 { |
275 { |
341 XAMetadataExtractionItfImpl *impl = NULL; |
276 XAMetadataExtractionItfImpl *impl = NULL; |
342 XAresult res = XA_RESULT_SUCCESS; |
277 XAresult res = XA_RESULT_SUCCESS; |
343 XAuint32 newidx = 0; |
278 |
344 |
|
345 XAuint32 neededsize = 0; |
|
346 |
|
347 XAuint32 newdatasize = 0; |
|
348 DEBUG_API("->XAMetadataExtractionItfImpl_GetValue"); |
279 DEBUG_API("->XAMetadataExtractionItfImpl_GetValue"); |
349 |
280 |
350 impl = GetImpl(self); |
281 impl = GetImpl(self); |
351 if (!impl || !pValue) |
282 if (!impl || !pValue) |
352 { |
283 { |
370 res = XA_RESULT_PARAMETER_INVALID; |
301 res = XA_RESULT_PARAMETER_INVALID; |
371 } |
302 } |
372 } |
303 } |
373 else |
304 else |
374 { |
305 { |
375 /* check index and return unfiltered index */ |
306 res = XA_RESULT_PARAMETER_INVALID; |
376 if (CheckAndUnfilterIndex(impl, index, &newidx) != XA_RESULT_SUCCESS) |
|
377 { |
|
378 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
379 DEBUG_API("<-XAMetadataExtractionItfImpl_GetValue"); |
|
380 return XA_RESULT_PARAMETER_INVALID; |
|
381 } |
|
382 |
|
383 /* needed size = size of struct + size of data - 1 (struct size already includes one char) */ |
|
384 neededsize = sizeof(XAMetadataInfo) |
|
385 + impl->currentTags.mdeValues[newidx]->size - 1; |
|
386 if (valueSize < neededsize) |
|
387 { /* cannot fit all of key data */ |
|
388 newdatasize = impl->currentTags.mdeValues[newidx]->size |
|
389 - (neededsize - valueSize); |
|
390 DEBUG_ERR("XA_RESULT_BUFFER_INSUFFICIENT"); |
|
391 res = XA_RESULT_BUFFER_INSUFFICIENT; |
|
392 } |
|
393 else |
|
394 { |
|
395 newdatasize = impl->currentTags.mdeValues[newidx]->size; |
|
396 res = XA_RESULT_SUCCESS; |
|
397 } |
|
398 /* copy data up to given size */ |
|
399 memcpy(pValue, impl->currentTags.mdeValues[newidx], valueSize - 1); |
|
400 /* ensure null-termination */ |
|
401 |
|
402 memset(pValue->data + newdatasize - 1, 0, 1); |
|
403 |
|
404 pValue->size = newdatasize; |
|
405 } |
307 } |
406 |
308 |
407 DEBUG_API_A1("<-XAMetadataExtractionItfImpl_GetValue (%d)",(int)res); |
309 DEBUG_API_A1("<-XAMetadataExtractionItfImpl_GetValue (%d)",(int)res); |
408 return res; |
310 return res; |
409 } |
311 } |
428 XAuint32 keyEncoding, const XAchar *pValueLangCountry, |
330 XAuint32 keyEncoding, const XAchar *pValueLangCountry, |
429 XAuint32 valueEncoding, XAuint8 filterMask) |
331 XAuint32 valueEncoding, XAuint8 filterMask) |
430 { |
332 { |
431 XAresult res = XA_RESULT_SUCCESS; |
333 XAresult res = XA_RESULT_SUCCESS; |
432 |
334 |
433 XAuint32 idx = 0; |
335 XAMetadataExtractionItfImpl *impl = NULL; |
434 XAuint8 matchMask = 0; |
336 |
435 |
|
436 XAMetadataExtractionItfImpl *impl = NULL; |
|
437 const XAchar* parsedkey; |
|
438 impl = GetImpl(self); |
337 impl = GetImpl(self); |
439 |
338 |
440 DEBUG_API("->XAMetadataExtractionItfImpl_AddKeyFilter"); |
339 DEBUG_API("->XAMetadataExtractionItfImpl_AddKeyFilter"); |
441 |
340 |
442 if (!impl) |
341 if (!impl) |
453 DEBUG_API("<-XAMetadataExtractionItfImpl_AddKeyFilter Not Supported in MMF"); |
352 DEBUG_API("<-XAMetadataExtractionItfImpl_AddKeyFilter Not Supported in MMF"); |
454 res = XA_RESULT_PARAMETER_INVALID; |
353 res = XA_RESULT_PARAMETER_INVALID; |
455 } |
354 } |
456 else |
355 else |
457 { |
356 { |
458 impl->filteringOn = XA_BOOLEAN_TRUE; |
357 DEBUG_API("<-XAMetadataExtractionItfImpl_AddKeyFilter Not Supported in GST"); |
459 for (idx = 0; idx < impl->currentTags.itemcount; idx++) |
358 res = XA_RESULT_PARAMETER_INVALID; |
460 { |
|
461 if ((filterMask & XA_METADATA_FILTER_KEY) && pKey) |
|
462 { |
|
463 parsedkey = XAMetadataAdapt_ParseKhronosKey(pKey); |
|
464 if (strcmp((char*) parsedkey, |
|
465 (char*) impl->currentTags.mdeKeys[idx]->data) |
|
466 == 0) |
|
467 { |
|
468 matchMask |= XA_METADATA_FILTER_KEY; |
|
469 } |
|
470 } |
|
471 if (filterMask & XA_METADATA_FILTER_LANG && pValueLangCountry) |
|
472 { |
|
473 if (strcmp( |
|
474 (char*) pValueLangCountry, |
|
475 (char*) impl->currentTags.mdeKeys[idx]->langCountry) |
|
476 == 0) |
|
477 { |
|
478 matchMask |= XA_METADATA_FILTER_LANG; |
|
479 } |
|
480 } |
|
481 if (filterMask & XA_METADATA_FILTER_ENCODING) |
|
482 { |
|
483 if (keyEncoding |
|
484 == impl->currentTags.mdeKeys[idx]->encoding) |
|
485 { |
|
486 matchMask |= XA_METADATA_FILTER_ENCODING; |
|
487 } |
|
488 if (valueEncoding |
|
489 == impl->currentTags.mdeValues[idx]->encoding) |
|
490 { |
|
491 matchMask |= XA_METADATA_FILTER_ENCODING; |
|
492 } |
|
493 } |
|
494 /* check if all filters apply */ |
|
495 if (filterMask == matchMask) |
|
496 { |
|
497 if (impl->tagmatchesfilter[idx] == XA_BOOLEAN_FALSE) |
|
498 { |
|
499 impl->tagmatchesfilter[idx] = XA_BOOLEAN_TRUE; |
|
500 impl->filteredcount++; |
|
501 } |
|
502 } |
|
503 /*reset matchmask*/ |
|
504 matchMask = 0; |
|
505 } |
|
506 } |
359 } |
507 } |
360 } |
508 DEBUG_API_A1("<-XAMetadataExtractionItfImpl_AddKeyFilter (%d)", (int)res); |
361 DEBUG_API_A1("<-XAMetadataExtractionItfImpl_AddKeyFilter (%d)", (int)res); |
509 return res; |
362 return res; |
510 } |
363 } |
516 XAMetadataExtractionItf self) |
369 XAMetadataExtractionItf self) |
517 { |
370 { |
518 XAMetadataExtractionItfImpl *impl = NULL; |
371 XAMetadataExtractionItfImpl *impl = NULL; |
519 XAresult res = XA_RESULT_SUCCESS; |
372 XAresult res = XA_RESULT_SUCCESS; |
520 |
373 |
521 XAuint32 idx = 0; |
|
522 |
|
523 DEBUG_API("->XAMetadataExtractionItfImpl_ClearKeyFilter"); |
374 DEBUG_API("->XAMetadataExtractionItfImpl_ClearKeyFilter"); |
524 impl = GetImpl(self); |
375 impl = GetImpl(self); |
525 if (!impl) |
376 if (!impl) |
526 { |
377 { |
527 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
378 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
535 DEBUG_API("<-XAMetadataExtractionItfImpl_ClearKeyFilter Not Supported in MMF"); |
386 DEBUG_API("<-XAMetadataExtractionItfImpl_ClearKeyFilter Not Supported in MMF"); |
536 res = XA_RESULT_PARAMETER_INVALID; |
387 res = XA_RESULT_PARAMETER_INVALID; |
537 } |
388 } |
538 else |
389 else |
539 { |
390 { |
540 if (impl->tagmatchesfilter) |
391 DEBUG_API("<-XAMetadataExtractionItfImpl_ClearKeyFilter Not Supported in GST"); |
541 { |
392 res = XA_RESULT_PARAMETER_INVALID; |
542 |
|
543 for (idx = 0; idx < impl->currentTags.itemcount; idx++) |
|
544 { |
|
545 impl->tagmatchesfilter[idx] = XA_BOOLEAN_FALSE; |
|
546 } |
|
547 |
|
548 } |
|
549 impl->filteredcount = 0; |
|
550 impl->filteringOn = XA_BOOLEAN_FALSE; |
|
551 } |
393 } |
552 } |
394 } |
553 |
395 |
554 DEBUG_API_A1("<-XAMetadataExtractionItfImpl_ClearKeyFilter (%d)", (int)res); |
396 DEBUG_API_A1("<-XAMetadataExtractionItfImpl_ClearKeyFilter (%d)", (int)res); |
555 return res; |
397 return res; |
581 self->itf.GetValue = XAMetadataExtractionItfImpl_GetValue; |
423 self->itf.GetValue = XAMetadataExtractionItfImpl_GetValue; |
582 self->itf.AddKeyFilter = XAMetadataExtractionItfImpl_AddKeyFilter; |
424 self->itf.AddKeyFilter = XAMetadataExtractionItfImpl_AddKeyFilter; |
583 self->itf.ClearKeyFilter = XAMetadataExtractionItfImpl_ClearKeyFilter; |
425 self->itf.ClearKeyFilter = XAMetadataExtractionItfImpl_ClearKeyFilter; |
584 |
426 |
585 /* init variables */ |
427 /* init variables */ |
586 self->filteredcount = 0; |
|
587 self->filteringOn = XA_BOOLEAN_FALSE; |
|
588 |
|
589 self->adaptCtx = adaptCtx; |
428 self->adaptCtx = adaptCtx; |
590 |
429 |
591 if (self->adaptCtx->fwtype != FWMgrFWMMF) |
430 if (self->adaptCtx->fwtype != FWMgrFWMMF) |
592 { |
431 { |
593 XAAdaptationBase_AddEventHandler(adaptCtx, |
432 XAAdaptationBase_AddEventHandler(adaptCtx, |
606 * Description: Free all resources reserved at XAMetadataExtractionItfImpl_Create |
445 * Description: Free all resources reserved at XAMetadataExtractionItfImpl_Create |
607 */ |
446 */ |
608 void XAMetadataExtractionItfImpl_Free(XAMetadataExtractionItfImpl* self) |
447 void XAMetadataExtractionItfImpl_Free(XAMetadataExtractionItfImpl* self) |
609 { |
448 { |
610 DEBUG_API("->XAMetadataExtractionItfImpl_Free"); |
449 DEBUG_API("->XAMetadataExtractionItfImpl_Free"); |
611 assert(self==self->self); |
|
612 |
450 |
613 if (self->adaptCtx->fwtype != FWMgrFWMMF) |
451 if (self->adaptCtx->fwtype != FWMgrFWMMF) |
614 { |
452 { |
615 XAAdaptationBase_RemoveEventHandler(self->adaptCtx, |
453 XAAdaptationBase_RemoveEventHandler(self->adaptCtx, |
616 &XAMetadataExtractionItfImp_AdaptCb); |
454 &XAMetadataExtractionItfImp_AdaptCb); |
617 XAMetadataAdapt_FreeImplTagList(&(self->currentTags), XA_BOOLEAN_TRUE); |
|
618 |
|
619 if (self->tagmatchesfilter) |
|
620 { |
|
621 free(self->tagmatchesfilter); |
|
622 } |
|
623 } |
455 } |
624 |
456 |
625 free(self); |
457 free(self); |
626 DEBUG_API("<-XAMetadataExtractionItfImpl_Free"); |
458 DEBUG_API("<-XAMetadataExtractionItfImpl_Free"); |
627 } |
459 } |
639 { |
471 { |
640 DEBUG_ERR("XAMetadataExtractionItfImp_AdaptCb, invalid context pointer!"); |
472 DEBUG_ERR("XAMetadataExtractionItfImp_AdaptCb, invalid context pointer!"); |
641 DEBUG_API("<-XAMetadataExtractionItfImp_AdaptCb"); |
473 DEBUG_API("<-XAMetadataExtractionItfImp_AdaptCb"); |
642 return; |
474 return; |
643 } |
475 } |
644 if (event && event->eventid == XA_ADAPT_MDE_TAGS_AVAILABLE) |
476 DEBUG_INFO("unhandled"); |
645 { |
|
646 /* get the tag list */ |
|
647 XAMetadataExtractionItfAdapt_FillTagList( |
|
648 (XAAdaptationGstCtx*) impl->adaptCtx, &(impl->currentTags)); |
|
649 if (impl->tagmatchesfilter) |
|
650 { |
|
651 free(impl->tagmatchesfilter); |
|
652 } |
|
653 impl->tagmatchesfilter = calloc(impl->currentTags.itemcount, |
|
654 sizeof(XAboolean)); |
|
655 impl->filteredcount = 0; |
|
656 } |
|
657 else |
|
658 { |
|
659 DEBUG_INFO("unhandled"); |
|
660 } |
|
661 DEBUG_API("<-XAMetadataExtractionItfImp_AdaptCb"); |
477 DEBUG_API("<-XAMetadataExtractionItfImp_AdaptCb"); |
662 } |
478 } |
663 |
479 |
664 /* For given index over filtered array, return index over whole array |
480 |
665 */ |
|
666 XAresult CheckAndUnfilterIndex(XAMetadataExtractionItfImpl *impl, |
|
667 XAuint32 oldidx, XAuint32 *newidx) |
|
668 { |
|
669 DEBUG_API("->CheckAndUnfilterIndex"); |
|
670 |
|
671 if (impl->filteringOn) |
|
672 { |
|
673 XAint16 i = -1; |
|
674 if (oldidx >= impl->filteredcount) |
|
675 { |
|
676 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
677 DEBUG_API("<-CheckAndUnfilterIndex"); |
|
678 return XA_RESULT_PARAMETER_INVALID; |
|
679 } |
|
680 *newidx = 0; |
|
681 while (*newidx < impl->currentTags.itemcount) |
|
682 { |
|
683 if (impl->tagmatchesfilter[*newidx]) |
|
684 i++; |
|
685 if (i < oldidx) |
|
686 (*newidx)++; |
|
687 else |
|
688 break; |
|
689 } |
|
690 if (*newidx == impl->currentTags.itemcount) |
|
691 { |
|
692 /* should not end up here */ |
|
693 *newidx = 0; |
|
694 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
695 DEBUG_API("<-CheckAndUnfilterIndex"); |
|
696 return XA_RESULT_PARAMETER_INVALID; |
|
697 } |
|
698 } |
|
699 else |
|
700 { |
|
701 if (oldidx >= impl->currentTags.itemcount) |
|
702 { |
|
703 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
704 DEBUG_API("<-CheckAndUnfilterIndex"); |
|
705 return XA_RESULT_PARAMETER_INVALID; |
|
706 } |
|
707 *newidx = oldidx; |
|
708 } |
|
709 |
|
710 DEBUG_API("<-CheckAndUnfilterIndex"); |
|
711 return XA_RESULT_SUCCESS; |
|
712 } |
|
713 |
|