frameworks/base/media/libeffects/lvm/lib/Bundle/src/LVM_Buffers.c

   1 /*
   2  * Copyright (C) 2004-2010 NXP Software
   3  * Copyright (C) 2010 The Android Open Source Project
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18
  19 /****************************************************************************************/
  20 /*                                                                                        */
  21 /*    Includes                                                                              */
  22 /*                                                                                        */
  23 /****************************************************************************************/
  24
  25 #include "LVM_Private.h"
  26 #include "VectorArithmetic.h"
  27
  28 /****************************************************************************************/
  29 /*                                                                                      */
  30 /* FUNCTION:                 LVM_BufferManagedIn                                        */
  31 /*                                                                                      */
  32 /* DESCRIPTION:                                                                         */
  33 /*    Full buffer management allowing the user to provide input and output buffers on   */
  34 /*  any alignment and with any number of samples. The alignment is corrected within     */
  35 /*  the buffer management and the samples are grouped in to blocks of the correct size  */
  36 /*  before processing.                                                                  */
  37 /*                                                                                      */
  38 /* PARAMETERS:                                                                          */
  39 /*    hInstance        -    Instance handle                                             */
  40 /*    pInData            -    Pointer to the input data stream                          */
  41 /*  *pToProcess        -    Pointer to pointer to the start of data processing          */
  42 /*  *pProcessed        -    Pointer to pointer to the destination of the processed data */
  43 /*    pNumSamples        -    Pointer to the number of samples to process               */
  44 /*                                                                                      */
  45 /* RETURNS:                                                                             */
  46 /*    None                                                                              */
  47 /*                                                                                      */
  48 /* NOTES:                                                                               */
  49 /*                                                                                      */
  50 /****************************************************************************************/
  51
  52 void LVM_BufferManagedIn(LVM_Handle_t       hInstance,
  53                          const LVM_INT16    *pInData,
  54                          LVM_INT16          **pToProcess,
  55                          LVM_INT16          **pProcessed,
  56                          LVM_UINT16         *pNumSamples)
  57 {
  58
  59     LVM_INT16        SampleCount;           /* Number of samples to be processed this call */
  60     LVM_INT16        NumSamples;            /* Number of samples in scratch buffer */
  61     LVM_INT16        *pStart;
  62     LVM_Instance_t   *pInstance = (LVM_Instance_t  *)hInstance;
  63     LVM_Buffer_t     *pBuffer;
  64     LVM_INT16        *pDest;
  65     LVM_INT16        NumChannels =2;
  66
  67
  68     /*
  69      * Set the processing address pointers
  70      */
  71     pBuffer     = pInstance->pBufferManagement;
  72     pDest       = pBuffer->pScratch;
  73     *pToProcess = pBuffer->pScratch;
  74     *pProcessed = pBuffer->pScratch;
  75
  76     /*
  77      * Check if it is the first call of a block
  78      */
  79     if (pInstance->SamplesToProcess == 0)
  80     {
  81         /*
  82          * First call for a new block of samples
  83          */
  84         pInstance->SamplesToProcess = (LVM_INT16)(*pNumSamples + pBuffer->InDelaySamples);
  85         pInstance->pInputSamples    = (LVM_INT16 *)pInData;
  86         pBuffer->BufferState        = LVM_FIRSTCALL;
  87     }
  88     pStart = pInstance->pInputSamples;                       /* Pointer to the input samples */
  89     pBuffer->SamplesToOutput  = 0;                           /* Samples to output is same as number read for inplace processing */
  90
  91
  92     /*
  93      * Calculate the number of samples to process this call and update the buffer state
  94      */
  95     if (pInstance->SamplesToProcess > pInstance->InternalBlockSize)
  96     {
  97         /*
  98          * Process the maximum bock size of samples.
  99          */
 100         SampleCount = pInstance->InternalBlockSize;
 101         NumSamples  = pInstance->InternalBlockSize;
 102     }
 103     else
 104     {
 105         /*
 106          * Last call for the block, so calculate how many frames and samples to process
 107           */
 108         LVM_INT16   NumFrames;
 109
 110         NumSamples  = pInstance->SamplesToProcess;
 111         NumFrames    = (LVM_INT16)(NumSamples >> MIN_INTERNAL_BLOCKSHIFT);
 112         SampleCount = (LVM_INT16)(NumFrames << MIN_INTERNAL_BLOCKSHIFT);
 113
 114         /*
 115          * Update the buffer state
 116          */
 117         if (pBuffer->BufferState == LVM_FIRSTCALL)
 118         {
 119             pBuffer->BufferState = LVM_FIRSTLASTCALL;
 120         }
 121         else
 122         {
 123             pBuffer->BufferState = LVM_LASTCALL;
 124         }
 125     }
 126     *pNumSamples = (LVM_UINT16)SampleCount;                        /* Set the number of samples to process this call */
 127
 128
 129     /*
 130      * Copy samples from the delay buffer as required
 131      */
 132     if (((pBuffer->BufferState == LVM_FIRSTCALL) ||
 133         (pBuffer->BufferState == LVM_FIRSTLASTCALL)) &&
 134         (pBuffer->InDelaySamples != 0))
 135     {
 136         Copy_16(&pBuffer->InDelayBuffer[0],                             /* Source */
 137                 pDest,                                                  /* Destination */
 138                 (LVM_INT16)(NumChannels*pBuffer->InDelaySamples));      /* Number of delay samples, left and right */
 139         NumSamples = (LVM_INT16)(NumSamples - pBuffer->InDelaySamples); /* Update sample count */
 140         pDest += NumChannels * pBuffer->InDelaySamples;                 /* Update the destination pointer */
 141     }
 142
 143
 144     /*
 145      * Copy the rest of the samples for this call from the input buffer
 146      */
 147     if (NumSamples > 0)
 148     {
 149         Copy_16(pStart,                                             /* Source */
 150                 pDest,                                              /* Destination */
 151                 (LVM_INT16)(NumChannels*NumSamples));               /* Number of input samples */
 152         pStart += NumChannels * NumSamples;                         /* Update the input pointer */
 153
 154         /*
 155          * Update the input data pointer and samples to output
 156          */
 157         pBuffer->SamplesToOutput = (LVM_INT16)(pBuffer->SamplesToOutput + NumSamples); /* Update samples to output */
 158     }
 159
 160
 161     /*
 162       * Update the sample count and input pointer
 163      */
 164     pInstance->SamplesToProcess  = (LVM_INT16)(pInstance->SamplesToProcess - SampleCount);      /* Update the count of samples */
 165     pInstance->pInputSamples     = pStart;                                                      /* Update input sample pointer */
 166
 167
 168     /*
 169      * Save samples to the delay buffer if any left unprocessed
 170      */
 171     if ((pBuffer->BufferState == LVM_FIRSTLASTCALL) ||
 172         (pBuffer->BufferState == LVM_LASTCALL))
 173     {
 174         NumSamples = pInstance->SamplesToProcess;
 175         pStart     = pBuffer->pScratch;                             /* Start of the buffer */
 176         pStart    += NumChannels*SampleCount;                       /* Offset by the number of processed samples */
 177         if (NumSamples != 0)
 178         {
 179             Copy_16(pStart,                                         /* Source */
 180                     &pBuffer->InDelayBuffer[0],                     /* Destination */
 181                     (LVM_INT16)(NumChannels*NumSamples));           /* Number of input samples */
 182         }
 183
 184
 185         /*
 186          * Update the delay sample count
 187          */
 188         pBuffer->InDelaySamples     = NumSamples;                   /* Number of delay sample pairs */
 189         pInstance->SamplesToProcess = 0;                            /* All Samples used */
 190     }
 191 }
 192
 193
 194 /****************************************************************************************/
 195 /*                                                                                      */
 196 /* FUNCTION:                 LVM_BufferUnmanagedIn                                      */
 197 /*                                                                                      */
 198 /* DESCRIPTION:                                                                         */
 199 /*    This mode is selected by the user code and disables the buffer management with the */
 200 /*  exception of the maximum block size processing. The user must ensure that the       */
 201 /*  input and output buffers are 32-bit aligned and also that the number of samples to  */
 202 /*    process is a correct multiple of samples.                                         */
 203 /*                                                                                      */
 204 /* PARAMETERS:                                                                          */
 205 /*    hInstance        -    Instance handle                                             */
 206 /*  *pToProcess        -    Pointer to the start of data processing                     */
 207 /*  *pProcessed        -    Pointer to the destination of the processed data            */
 208 /*    pNumSamples        -    Pointer to the number of samples to process               */
 209 /*                                                                                      */
 210 /* RETURNS:                                                                             */
 211 /*    None                                                                              */
 212 /*                                                                                      */
 213 /* NOTES:                                                                               */
 214 /*                                                                                      */
 215 /****************************************************************************************/
 216
 217 void LVM_BufferUnmanagedIn(LVM_Handle_t     hInstance,
 218                            LVM_INT16        **pToProcess,
 219                            LVM_INT16        **pProcessed,
 220                            LVM_UINT16       *pNumSamples)
 221 {
 222
 223     LVM_Instance_t    *pInstance = (LVM_Instance_t  *)hInstance;
 224
 225
 226     /*
 227      * Check if this is the first call of a block
 228      */
 229     if (pInstance->SamplesToProcess == 0)
 230     {
 231         pInstance->SamplesToProcess = (LVM_INT16)*pNumSamples;       /* Get the number of samples on first call */
 232         pInstance->pInputSamples    = *pToProcess;                   /* Get the I/O pointers */
 233         pInstance->pOutputSamples    = *pProcessed;
 234
 235
 236         /*
 237          * Set te block size to process
 238          */
 239         if (pInstance->SamplesToProcess > pInstance->InternalBlockSize)
 240         {
 241             *pNumSamples = (LVM_UINT16)pInstance->InternalBlockSize;
 242         }
 243         else
 244         {
 245             *pNumSamples = (LVM_UINT16)pInstance->SamplesToProcess;
 246         }
 247     }
 248
 249     /*
 250      * Set the process pointers
 251      */
 252     *pToProcess = pInstance->pInputSamples;
 253     *pProcessed = pInstance->pOutputSamples;
 254 }
 255
 256
 257 /****************************************************************************************/
 258 /*                                                                                      */
 259 /* FUNCTION:                 LVM_BufferOptimisedIn                                      */
 260 /*                                                                                      */
 261 /* DESCRIPTION:                                                                         */
 262 /*    Optimised buffer management for the case where the data is outplace processing,   */
 263 /*    the output data is 32-bit aligned and there are sufficient samples to allow some  */
 264 /*    processing directly in the output buffer. This saves one data copy per sample     */
 265 /*    compared with the unoptimsed version.                                             */
 266 /*                                                                                      */
 267 /* PARAMETERS:                                                                          */
 268 /*    hInstance        -    Instance handle                                             */
 269 /*    pInData            -    Pointer to the input data stream                          */
 270 /*  *pToProcess        -    Pointer to the start of data processing                     */
 271 /*  *pProcessed        -    Pointer to the destination of the processed data            */
 272 /*    pNumSamples        -    Pointer to the number of samples to process               */
 273 /*                                                                                      */
 274 /* RETURNS:                                                                             */
 275 /*    None                                                                              */
 276 /*                                                                                      */
 277 /* NOTES:                                                                               */
 278 /*                                                                                      */
 279 /****************************************************************************************/
 280
 281 void LVM_BufferOptimisedIn(LVM_Handle_t         hInstance,
 282                            const LVM_INT16      *pInData,
 283                            LVM_INT16            **pToProcess,
 284                            LVM_INT16            **pProcessed,
 285                            LVM_UINT16           *pNumSamples)
 286 {
 287
 288     LVM_Instance_t   *pInstance = (LVM_Instance_t  *)hInstance;
 289     LVM_Buffer_t     *pBuffer    = pInstance->pBufferManagement;
 290     LVM_INT16        *pDest;
 291     LVM_INT16        SampleCount;
 292     LVM_INT16        NumSamples;
 293     LVM_INT16        NumFrames;
 294
 295     /*
 296      * Check if it is the first call for this block
 297      */
 298     if (pInstance->SamplesToProcess == 0)
 299     {
 300         /*
 301          * First call for a new block of samples
 302          */
 303         pBuffer->BufferState = LVM_FIRSTCALL;
 304         pInstance->pInputSamples    = (LVM_INT16 *)pInData;
 305         pInstance->SamplesToProcess = (LVM_INT16)*pNumSamples;
 306         pBuffer->SamplesToOutput    = (LVM_INT16)*pNumSamples;
 307         pDest = *pProcessed;                                    /* The start of the output buffer */
 308
 309
 310         /*
 311          * Copy the already processed samples to the output buffer
 312          */
 313         if (pBuffer->OutDelaySamples != 0)
 314         {
 315             Copy_16(&pBuffer->OutDelayBuffer[0],                    /* Source */
 316                     pDest,                                          /* Detsination */
 317                     (LVM_INT16)(2*pBuffer->OutDelaySamples));       /* Number of delay samples */
 318             pDest += 2 * pBuffer->OutDelaySamples;                  /* Update the output pointer */
 319             pBuffer->SamplesToOutput = (LVM_INT16)(pBuffer->SamplesToOutput - pBuffer->OutDelaySamples); /* Update the numbr of samples to output */
 320         }
 321         *pToProcess = pDest;                                    /* Set the address to start processing */
 322         *pProcessed = pDest;                                    /* Process in the output buffer, now inplace */
 323
 324         /*
 325          * Copy the input delay buffer (unprocessed) samples to the output buffer
 326          */
 327         if (pBuffer->InDelaySamples != 0)
 328         {
 329             Copy_16(&pBuffer->InDelayBuffer[0],                     /* Source */
 330                     pDest,                                          /* Destination */
 331                     (LVM_INT16)(2*pBuffer->InDelaySamples));        /* Number of delay samples */
 332             pDest += 2 * pBuffer->InDelaySamples;                   /* Update the output pointer */
 333         }
 334
 335
 336         /*
 337          * Calculate how many input samples to process and copy
 338          */
 339         NumSamples    = (LVM_INT16)(*pNumSamples - pBuffer->OutDelaySamples);  /* Number that will fit in the output buffer */
 340         if (NumSamples >= pInstance->InternalBlockSize)
 341         {
 342             NumSamples = pInstance->InternalBlockSize;
 343         }
 344         NumFrames      = (LVM_INT16)(NumSamples >> MIN_INTERNAL_BLOCKSHIFT);
 345         SampleCount   = (LVM_INT16)(NumFrames << MIN_INTERNAL_BLOCKSHIFT);
 346         *pNumSamples  = (LVM_UINT16)SampleCount;                                        /* The number of samples to process */
 347         pBuffer->SamplesToOutput = (LVM_INT16)(pBuffer->SamplesToOutput - SampleCount); /* Update the number of samples to output */
 348         SampleCount   = (LVM_INT16)(SampleCount - pBuffer->InDelaySamples);             /* The number of samples to copy from the input */
 349
 350
 351         /*
 352          * Copy samples from the input buffer and update counts and pointers
 353          */
 354         Copy_16(pInstance->pInputSamples,                           /* Source */
 355                 pDest,                                              /* Destination */
 356                 (LVM_INT16)(2*SampleCount));                        /* Number of input samples */
 357         pInstance->pInputSamples += 2 * SampleCount;                /* Update the input pointer */
 358         pInstance->pOutputSamples = pDest + (2 * SampleCount);      /* Update the output pointer */
 359         pInstance->SamplesToProcess = (LVM_INT16)(pInstance->SamplesToProcess - SampleCount); /* Samples left in the input buffer */
 360     }
 361     else
 362     {
 363         /*
 364          * Second or subsequent call in optimised mode
 365          */
 366         if (pBuffer->SamplesToOutput >= MIN_INTERNAL_BLOCKSIZE)
 367         {
 368             /*
 369              * More samples can be processed directly in the output buffer
 370              */
 371             *pToProcess = pInstance->pOutputSamples;                /* Set the address to start processing */
 372             *pProcessed = pInstance->pOutputSamples;                /* Process in the output buffer, now inplace */
 373             NumSamples  = pBuffer->SamplesToOutput;                 /* Number that will fit in the output buffer */
 374             if (NumSamples >= pInstance->InternalBlockSize)
 375             {
 376                 NumSamples = pInstance->InternalBlockSize;
 377             }
 378             NumFrames      = (LVM_INT16)(NumSamples >> MIN_INTERNAL_BLOCKSHIFT);
 379             SampleCount   = (LVM_INT16)(NumFrames << MIN_INTERNAL_BLOCKSHIFT);
 380             *pNumSamples  = (LVM_UINT16)SampleCount;            /* The number of samples to process */
 381
 382
 383             /*
 384              * Copy samples from the input buffer and update counts and pointers
 385              */
 386             Copy_16(pInstance->pInputSamples,                       /* Source */
 387                     pInstance->pOutputSamples,                      /* Destination */
 388                     (LVM_INT16)(2*SampleCount));                    /* Number of input samples */
 389             pInstance->pInputSamples += 2 * SampleCount;            /* Update the input pointer */
 390             pInstance->pOutputSamples += 2 * SampleCount;           /* Update the output pointer */
 391             pInstance->SamplesToProcess = (LVM_INT16)(pInstance->SamplesToProcess - SampleCount);   /* Samples left in the input buffer */
 392             pBuffer->SamplesToOutput = (LVM_INT16)(pBuffer->SamplesToOutput - SampleCount);         /* Number that will fit in the output buffer */
 393         }
 394         else
 395         {
 396             /*
 397              * The remaining samples can not be processed in the output buffer
 398              */
 399             pBuffer->BufferState = LVM_LASTCALL;                    /* Indicate this is the last bock to process */
 400             *pToProcess  = pBuffer->pScratch;                       /* Set the address to start processing */
 401             *pProcessed  = pBuffer->pScratch;                       /* Process in the output buffer, now inplace */
 402             NumSamples   = pInstance->SamplesToProcess;             /* Number left to be processed */
 403             NumFrames     = (LVM_INT16)(NumSamples >> MIN_INTERNAL_BLOCKSHIFT);
 404             SampleCount  = (LVM_INT16)(NumFrames << MIN_INTERNAL_BLOCKSHIFT);
 405             *pNumSamples = (LVM_UINT16)SampleCount;                /* The number of samples to process */
 406
 407
 408             /*
 409              * Copy samples from the input buffer and update counts and pointers
 410              */
 411             Copy_16(pInstance->pInputSamples,                       /* Source */
 412                     pBuffer->pScratch,                              /* Destination */
 413                     (LVM_INT16)(2*SampleCount));                    /* Number of input samples */
 414             pInstance->pInputSamples += 2 * SampleCount;            /* Update the input pointer */
 415             pInstance->SamplesToProcess = (LVM_INT16)(pInstance->SamplesToProcess - SampleCount); /* Samples left in the input buffer */
 416         }
 417     }
 418 }
 419
 420 /****************************************************************************************/
 421 /*                                                                                      */
 422 /* FUNCTION:                 LVM_BufferIn                                               */
 423 /*                                                                                      */
 424 /* DESCRIPTION:                                                                         */
 425 /*    This function manages the data input, it has the following features:              */
 426 /*        - Accepts data in 16-bit aligned memory                                       */
 427 /*        - Copies the data to 32-bit aligned memory                                    */
 428 /*        - Converts Mono inputs to Mono-in-Stereo                                      */
 429 /*        - Accepts any number of samples as input, except 0                            */
 430 /*        - Breaks the input sample stream in to blocks of the configured frame size or */
 431 /*          multiples of the frame size                                                 */
 432 /*        - Limits the processing block size to the maximum block size.                 */
 433 /*        - Works with inplace or outplace processing automatically                     */
 434 /*                                                                                      */
 435 /*  To manage the data the function has a number of operating states:                   */
 436 /*        LVM_FIRSTCALL        - The first call for this block of input samples         */
 437 /*        LVM_MAXBLOCKCALL    - The current block is the maximum size. Only used for the */
 438 /*                              second and subsequent blocks.                           */
 439 /*        LVM_LASTCALL        - The last call for this block of input samples           */
 440 /*        LVM_FIRSTLASTCALL    - This is the first and last call for this block of input*/
 441 /*                              samples, this occurs when the number of samples to      */
 442 /*                              process is less than the maximum block size.            */
 443 /*                                                                                      */
 444 /*    The function uses an internal delay buffer the size of the minimum frame, this is */
 445 /*  used to temporarily hold samples when the number of samples to process is not a     */
 446 /*  multiple of the frame size.                                                         */
 447 /*                                                                                      */
 448 /*    To ensure correct operation with inplace buffering the number of samples to output*/
 449 /*  per call is calculated in this function and is set to the number of samples read    */
 450 /*  from the input buffer.                                                              */
 451 /*                                                                                      */
 452 /*    The total number of samples to process is stored when the function is called for  */
 453 /*  the first time. The value is overwritten by the size of the block to be processed   */
 454 /*  in each call so the size of the processing blocks can be controlled. The number of  */
 455 /*    samples actually processed for each block of input samples is always a multiple of*/
 456 /*  the frame size so for any particular block of input samples the actual number of    */
 457 /*  processed samples may not match the number of input samples, sometime it will be    */
 458 /*  sometimes less. The average is the same and the difference is never more than the   */
 459 /*  frame size.                                                                         */
 460 /*                                                                                      */
 461 /* PARAMETERS:                                                                          */
 462 /*    hInstance        -    Instance handle                                             */
 463 /*    pInData            -    Pointer to the input data stream                          */
 464 /*  *pToProcess        -    Pointer to the start of data processing                     */
 465 /*  *pProcessed        -    Pointer to the destination of the processed data            */
 466 /*    pNumSamples        -    Pointer to the number of samples to process               */
 467 /*                                                                                      */
 468 /* RETURNS:                                                                             */
 469 /*    None                                                                              */
 470 /*                                                                                      */
 471 /* NOTES:                                                                               */
 472 /*                                                                                      */
 473 /****************************************************************************************/
 474
 475 void LVM_BufferIn(LVM_Handle_t      hInstance,
 476                   const LVM_INT16   *pInData,
 477                   LVM_INT16         **pToProcess,
 478                   LVM_INT16         **pProcessed,
 479                   LVM_UINT16        *pNumSamples)
 480 {
 481
 482     LVM_Instance_t    *pInstance = (LVM_Instance_t  *)hInstance;
 483
 484
 485     /*
 486      * Check which mode, managed or unmanaged
 487      */
 488     if (pInstance->InstParams.BufferMode == LVM_MANAGED_BUFFERS)
 489     {
 490         LVM_BufferManagedIn(hInstance,
 491                             pInData,
 492                             pToProcess,
 493                             pProcessed,
 494                             pNumSamples);
 495     }
 496     else
 497     {
 498         LVM_BufferUnmanagedIn(hInstance,
 499                               pToProcess,
 500                               pProcessed,
 501                               pNumSamples);
 502     }
 503 }
 504
 505 /****************************************************************************************/
 506 /*                                                                                      */
 507 /* FUNCTION:                 LVM_BufferManagedOut                                       */
 508 /*                                                                                      */
 509 /* DESCRIPTION:                                                                         */
 510 /*  Full buffer management output. This works in conjunction with the managed input     */
 511 /*  routine and ensures the correct number of samples are always output to the output   */
 512 /*  buffer.                                                                             */
 513 /*                                                                                      */
 514 /* PARAMETERS:                                                                          */
 515 /*    hInstance        - Instance handle                                                */
 516 /*    pOutData        - Pointer to the output data stream                               */
 517 /*    pNumSamples        - Pointer to the number of samples to process                  */
 518 /*                                                                                      */
 519 /* RETURNS:                                                                             */
 520 /*    None                                                                              */
 521 /*                                                                                      */
 522 /* NOTES:                                                                               */
 523 /*                                                                                      */
 524 /****************************************************************************************/
 525
 526 void LVM_BufferManagedOut(LVM_Handle_t        hInstance,
 527                           LVM_INT16            *pOutData,
 528                           LVM_UINT16        *pNumSamples)
 529 {
 530
 531     LVM_Instance_t  *pInstance  = (LVM_Instance_t  *)hInstance;
 532     LVM_Buffer_t    *pBuffer    = pInstance->pBufferManagement;
 533     LVM_INT16       SampleCount = (LVM_INT16)*pNumSamples;
 534     LVM_INT16       NumSamples;
 535     LVM_INT16       *pStart;
 536     LVM_INT16       *pDest;
 537
 538
 539     /*
 540      * Set the pointers
 541      */
 542     NumSamples = pBuffer->SamplesToOutput;
 543     pStart     = pBuffer->pScratch;
 544
 545
 546     /*
 547      * check if it is the first call of a block
 548       */
 549     if ((pBuffer->BufferState == LVM_FIRSTCALL) ||
 550         (pBuffer->BufferState == LVM_FIRSTLASTCALL))
 551     {
 552         /* First call for a new block */
 553         pInstance->pOutputSamples = pOutData;                        /* Initialise the destination */
 554     }
 555     pDest = pInstance->pOutputSamples;                               /* Set the output address */
 556
 557
 558     /*
 559      * If the number of samples is non-zero then there are still samples to send to
 560      * the output buffer
 561      */
 562     if ((NumSamples != 0) &&
 563         (pBuffer->OutDelaySamples != 0))
 564     {
 565         /*
 566          * Copy the delayed output buffer samples to the output
 567          */
 568         if (pBuffer->OutDelaySamples <= NumSamples)
 569         {
 570             /*
 571              * Copy all output delay samples to the output
 572              */
 573             Copy_16(&pBuffer->OutDelayBuffer[0],                    /* Source */
 574                     pDest,                                          /* Detsination */
 575                     (LVM_INT16)(2*pBuffer->OutDelaySamples));       /* Number of delay samples */
 576
 577             /*
 578              * Update the pointer and sample counts
 579              */
 580             pDest += 2*pBuffer->OutDelaySamples;                                /* Output sample pointer */
 581             NumSamples = (LVM_INT16)(NumSamples - pBuffer->OutDelaySamples);    /* Samples left to send */
 582             pBuffer->OutDelaySamples = 0;                                       /* No samples left in the buffer */
 583
 584         }
 585         else
 586         {
 587             /*
 588              * Copy only some of the ouput delay samples to the output
 589              */
 590             Copy_16(&pBuffer->OutDelayBuffer[0],                    /* Source */
 591                     pDest,                                          /* Detsination */
 592                     (LVM_INT16)(2*NumSamples));                     /* Number of delay samples */
 593
 594             /*
 595              * Update the pointer and sample counts
 596              */
 597             pDest += 2*NumSamples;                                                              /* Output sample pointer */
 598             pBuffer->OutDelaySamples = (LVM_INT16)(pBuffer->OutDelaySamples - NumSamples);      /* No samples left in the buffer */
 599
 600
 601             /*
 602              * Realign the delay buffer data to avoid using circular buffer management
 603              */
 604             Copy_16(&pBuffer->OutDelayBuffer[2*NumSamples],         /* Source */
 605                     &pBuffer->OutDelayBuffer[0],                    /* Destination */
 606                     (LVM_INT16)(2*pBuffer->OutDelaySamples));       /* Number of samples to move */
 607             NumSamples = 0;                                         /* Samples left to send */
 608         }
 609     }
 610
 611
 612     /*
 613      * Copy the processed results to the output
 614      */
 615     if ((NumSamples != 0) &&
 616         (SampleCount != 0))
 617     {
 618         if (SampleCount <= NumSamples)
 619         {
 620             /*
 621              * Copy all processed samples to the output
 622              */
 623             Copy_16(pStart,                                      /* Source */
 624                     pDest,                                       /* Detsination */
 625                     (LVM_INT16)(2*SampleCount));                 /* Number of processed samples */
 626
 627             /*
 628              * Update the pointer and sample counts
 629              */
 630             pDest      += 2 * SampleCount;                          /* Output sample pointer */
 631             NumSamples  = (LVM_INT16)(NumSamples - SampleCount);    /* Samples left to send */
 632             SampleCount = 0;                                        /* No samples left in the buffer */
 633         }
 634         else
 635         {
 636             /*
 637              * Copy only some processed samples to the output
 638              */
 639             Copy_16(pStart,                                         /* Source */
 640                     pDest,                                          /* Destination */
 641                     (LVM_INT16)(2*NumSamples));                     /* Number of processed samples */
 642
 643
 644             /*
 645              * Update the pointers and sample counts
 646                */
 647             pStart      += 2 * NumSamples;                          /* Processed sample pointer */
 648             pDest        += 2 * NumSamples;                         /* Output sample pointer */
 649             SampleCount  = (LVM_INT16)(SampleCount - NumSamples);   /* Processed samples left */
 650             NumSamples   = 0;                                       /* Clear the sample count */
 651         }
 652     }
 653
 654
 655     /*
 656      * Copy the remaining processed data to the output delay buffer
 657      */
 658     if (SampleCount != 0)
 659     {
 660         Copy_16(pStart,                                                 /* Source */
 661                 &pBuffer->OutDelayBuffer[2*pBuffer->OutDelaySamples],   /* Destination */
 662                 (LVM_INT16)(2*SampleCount));                            /* Number of processed samples */
 663         pBuffer->OutDelaySamples = (LVM_INT16)(pBuffer->OutDelaySamples + SampleCount); /* Update the buffer count */
 664     }
 665
 666
 667     /*
 668      * pointers, counts and set default buffer processing
 669      */
 670     pBuffer->SamplesToOutput  = NumSamples;                         /* Samples left to send */
 671     pInstance->pOutputSamples = pDest;                              /* Output sample pointer */
 672     pBuffer->BufferState      = LVM_MAXBLOCKCALL;                   /* Set for the default call block size */
 673     *pNumSamples = (LVM_UINT16)pInstance->SamplesToProcess;         /* This will terminate the loop when all samples processed */
 674 }
 675
 676
 677 /****************************************************************************************/
 678 /*                                                                                      */
 679 /* FUNCTION:                 LVM_BufferUnmanagedOut                                     */
 680 /*                                                                                      */
 681 /* DESCRIPTION:                                                                         */
 682 /*  This works in conjunction with the unmanaged input routine and updates the number   */
 683 /*    of samples left to be processed    and adjusts the buffer pointers.               */
 684 /*                                                                                      */
 685 /* PARAMETERS:                                                                          */
 686 /*    hInstance        - Instance handle                                                */
 687 /*    pNumSamples        - Pointer to the number of samples to process                  */
 688 /*                                                                                      */
 689 /* RETURNS:                                                                             */
 690 /*    None                                                                              */
 691 /*                                                                                      */
 692 /* NOTES:                                                                               */
 693 /*                                                                                      */
 694 /****************************************************************************************/
 695
 696 void LVM_BufferUnmanagedOut(LVM_Handle_t        hInstance,
 697                             LVM_UINT16          *pNumSamples)
 698 {
 699
 700     LVM_Instance_t      *pInstance  = (LVM_Instance_t  *)hInstance;
 701     LVM_INT16           NumChannels =2;
 702
 703
 704     /*
 705      * Update sample counts
 706      */
 707     pInstance->pInputSamples    += (LVM_INT16)(*pNumSamples * NumChannels); /* Update the I/O pointers */
 708     pInstance->pOutputSamples   += (LVM_INT16)(*pNumSamples * 2);
 709     pInstance->SamplesToProcess  = (LVM_INT16)(pInstance->SamplesToProcess - *pNumSamples); /* Update the sample count */
 710
 711     /*
 712      * Set te block size to process
 713      */
 714     if (pInstance->SamplesToProcess > pInstance->InternalBlockSize)
 715     {
 716         *pNumSamples = (LVM_UINT16)pInstance->InternalBlockSize;
 717     }
 718     else
 719     {
 720         *pNumSamples = (LVM_UINT16)pInstance->SamplesToProcess;
 721     }
 722 }
 723
 724
 725 /****************************************************************************************/
 726 /*                                                                                      */
 727 /* FUNCTION:                 LVM_BufferOptimisedOut                                     */
 728 /*                                                                                      */
 729 /* DESCRIPTION:                                                                         */
 730 /*  This works in conjunction with the optimised input routine and copies the last few  */
 731 /*  processed and unprocessed samples to their respective buffers.                      */
 732 /*                                                                                      */
 733 /* PARAMETERS:                                                                          */
 734 /*    hInstance        - Instance handle                                                */
 735 /*    pNumSamples        - Pointer to the number of samples to process                  */
 736 /*                                                                                      */
 737 /* RETURNS:                                                                             */
 738 /*    None                                                                              */
 739 /*                                                                                      */
 740 /* NOTES:                                                                               */
 741 /*                                                                                      */
 742 /****************************************************************************************/
 743
 744 void LVM_BufferOptimisedOut(LVM_Handle_t    hInstance,
 745                             LVM_UINT16        *pNumSamples)
 746 {
 747
 748     LVM_Instance_t      *pInstance = (LVM_Instance_t  *)hInstance;
 749     LVM_Buffer_t        *pBuffer   = pInstance->pBufferManagement;
 750
 751     /*
 752      * Check if it is the last block to process
 753      */
 754     if (pBuffer->BufferState == LVM_LASTCALL)
 755     {
 756         LVM_INT16    *pSrc = pBuffer->pScratch;
 757
 758         /*
 759          * Copy the unprocessed samples to the input delay buffer
 760          */
 761         if (pInstance->SamplesToProcess != 0)
 762         {
 763             Copy_16(pInstance->pInputSamples,                       /* Source */
 764                     &pBuffer->InDelayBuffer[0],                     /* Destination */
 765                     (LVM_INT16)(2*pInstance->SamplesToProcess));    /* Number of input samples */
 766             pBuffer->InDelaySamples = pInstance->SamplesToProcess;
 767             pInstance->SamplesToProcess = 0;
 768         }
 769         else
 770         {
 771             pBuffer->InDelaySamples = 0;
 772         }
 773
 774
 775         /*
 776          * Fill the last empty spaces in the output buffer
 777          */
 778         if (pBuffer->SamplesToOutput != 0)
 779         {
 780             Copy_16(pSrc,                                           /* Source */
 781                     pInstance->pOutputSamples,                      /* Destination */
 782                     (LVM_INT16)(2*pBuffer->SamplesToOutput));       /* Number of input samples */
 783             *pNumSamples = (LVM_UINT16)(*pNumSamples - pBuffer->SamplesToOutput);
 784             pSrc += 2 * pBuffer->SamplesToOutput;                  /* Update scratch pointer */
 785             pBuffer->SamplesToOutput = 0;                          /* No more samples in this block */
 786         }
 787
 788
 789         /*
 790          * Save any remaining processed samples in the output delay buffer
 791          */
 792         if (*pNumSamples != 0)
 793         {
 794             Copy_16(pSrc,                                           /* Source */
 795                     &pBuffer->OutDelayBuffer[0],                    /* Destination */
 796                     (LVM_INT16)(2**pNumSamples));                   /* Number of input samples */
 797
 798             pBuffer->OutDelaySamples = (LVM_INT16)*pNumSamples;
 799
 800             *pNumSamples = 0;                                      /* No more samples in this block */
 801         }
 802         else
 803         {
 804             pBuffer->OutDelaySamples = 0;
 805         }
 806     }
 807 }
 808
 809
 810 /****************************************************************************************/
 811 /*                                                                                      */
 812 /* FUNCTION:                 LVM_BufferOut                                              */
 813 /*                                                                                      */
 814 /* DESCRIPTION:                                                                         */
 815 /*  This function manages the data output, it has the following features:               */
 816 /*        - Output data to 16-bit aligned memory                                        */
 817 /*        - Reads data from 32-bit aligned memory                                       */
 818 /*        - Reads data only in blocks of frame size or multiples of frame size          */
 819 /*        - Writes the same number of samples as the LVM_BufferIn function reads        */
 820 /*        - Works with inplace or outplace processing automatically                     */
 821 /*                                                                                      */
 822 /*  To manage the data the function has a number of operating states:                   */
 823 /*        LVM_FIRSTCALL        - The first call for this block of input samples         */
 824 /*        LVM_FIRSTLASTCALL    - This is the first and last call for this block of input*/
 825 /*                              samples, this occurs when the number of samples to      */
 826 /*                              process is less than the maximum block size.            */
 827 /*                                                                                      */
 828 /*    The function uses an internal delay buffer the size of the minimum frame, this is */
 829 /*  used to temporarily hold samples when the number of samples to write is not a       */
 830 /*  multiple of the frame size.                                                         */
 831 /*                                                                                      */
 832 /*    To ensure correct operation with inplace buffering the number of samples to output*/
 833 /*  per call is always the same as the number of samples read from the input buffer.    */
 834 /*                                                                                      */
 835 /* PARAMETERS:                                                                          */
 836 /*    hInstance        - Instance handle                                                */
 837 /*    pOutData        - Pointer to the output data stream                               */
 838 /*    pNumSamples        - Pointer to the number of samples to process                  */
 839 /*                                                                                      */
 840 /* RETURNS:                                                                             */
 841 /*    None                                                                              */
 842 /*                                                                                      */
 843 /* NOTES:                                                                               */
 844 /*                                                                                      */
 845 /****************************************************************************************/
 846
 847 void LVM_BufferOut(LVM_Handle_t     hInstance,
 848                    LVM_INT16        *pOutData,
 849                    LVM_UINT16       *pNumSamples)
 850 {
 851
 852     LVM_Instance_t    *pInstance  = (LVM_Instance_t  *)hInstance;
 853
 854
 855     /*
 856      * Check which mode, managed or unmanaged
 857      */
 858     if (pInstance->InstParams.BufferMode == LVM_MANAGED_BUFFERS)
 859     {
 860         LVM_BufferManagedOut(hInstance,
 861                              pOutData,
 862                              pNumSamples);
 863     }
 864     else
 865     {
 866         LVM_BufferUnmanagedOut(hInstance,
 867                                pNumSamples);
 868     }
 869 }
 870