1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/mm/mmplugins/lib3gp/impl/src/metadatafilewriter.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,555 @@
1.4 +// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +
1.20 +// INCLUDE FILES
1.21 +#include <e32base.h>
1.22 +#include <f32file.h>
1.23 +#include "mp4atom.h"
1.24 +#include "metadatafilewriter.h"
1.25 +
1.26 +// MACROS
1.27 +// Debug print macro
1.28 +#ifdef _DEBUG
1.29 +#include <e32svr.h>
1.30 +#define PRINT(x)
1.31 +#else
1.32 +#define PRINT(x)
1.33 +#endif
1.34 +
1.35 +const TInt KMetaDataWriterBufferSize = (4*4096);
1.36 +const TInt KMetaDataWriterInputBufCount = 10;
1.37 +const TInt KMetaDataWriterOutputBufCount = 4;
1.38 +
1.39 +// ============================ MEMBER FUNCTIONS ===============================
1.40 +
1.41 +CMetaDataWriterBuffer::~CMetaDataWriterBuffer()
1.42 + {
1.43 + delete iData;
1.44 + }
1.45 +
1.46 +// -----------------------------------------------------------------------------
1.47 +// CMetaDataFileWriter::CMetaDataFileWriter
1.48 +// C++ default constructor can NOT contain any code, that
1.49 +// might leave.
1.50 +// -----------------------------------------------------------------------------
1.51 +//
1.52 +CMetaDataFileWriter::CMetaDataFileWriter() : CActive( EPriorityHigh )
1.53 + {
1.54 + }
1.55 +
1.56 +// -----------------------------------------------------------------------------
1.57 +// CMetaDataFileWriter::ConstructL
1.58 +// Symbian 2nd phase constructor can leave.
1.59 +// -----------------------------------------------------------------------------
1.60 +//
1.61 +void CMetaDataFileWriter::ConstructL( )
1.62 + {
1.63 + PRINT(_L("CMetaDataFileWriter::ConstructL() in"));
1.64 +
1.65 + iError = KErrNone;
1.66 + iAsyncWritingOngoing = EFalse;
1.67 + iFlush = EFalse;
1.68 + iFlushDone = EFalse;
1.69 +
1.70 + for (TInt i=0; i<KMetaDataWriterInputBufCount; i++)
1.71 + {
1.72 + iOutputFile.AppendL(NULL);
1.73 +
1.74 + CMetaDataWriterBuffer* emptyInputBuffer = new (ELeave) CMetaDataWriterBuffer;
1.75 + CleanupStack::PushL(emptyInputBuffer);
1.76 +
1.77 + emptyInputBuffer->iData = HBufC8::NewL(KMetaDataWriterBufferSize);
1.78 + emptyInputBuffer->iOutputFileNum = i;
1.79 + iInputBufferArray.AppendL(emptyInputBuffer);
1.80 +
1.81 + CleanupStack::Pop(emptyInputBuffer);
1.82 +
1.83 + iInputBufferArrayDelivered[i] = 0;
1.84 + }
1.85 +
1.86 + for (TInt j=0; j<KMetaDataWriterOutputBufCount; j++)
1.87 + {
1.88 + CMetaDataWriterBuffer* emptyOutputBuffer = new (ELeave) CMetaDataWriterBuffer;
1.89 + CleanupStack::PushL(emptyOutputBuffer);
1.90 +
1.91 + emptyOutputBuffer->iData = HBufC8::NewL(KMetaDataWriterBufferSize);
1.92 + emptyOutputBuffer->iOutputFileNum = -1;
1.93 + iEmptyBufferQueue.AppendL(emptyOutputBuffer);
1.94 +
1.95 + CleanupStack::Pop(emptyOutputBuffer);
1.96 + }
1.97 +
1.98 + CActiveScheduler::Add(this);
1.99 +
1.100 + PRINT(_L("CMetaDataFileWriter::ConstructL() out"));
1.101 + }
1.102 +
1.103 +// -----------------------------------------------------------------------------
1.104 +// CMetaDataFileWriter::NewL
1.105 +// Two-phased constructor.
1.106 +// -----------------------------------------------------------------------------
1.107 +//
1.108 +CMetaDataFileWriter* CMetaDataFileWriter::NewL()
1.109 + {
1.110 + PRINT(_L("CMetaDataFileWriter::NewL() in"));
1.111 +
1.112 + CMetaDataFileWriter* self = new(ELeave) CMetaDataFileWriter;
1.113 + CleanupStack::PushL(self);
1.114 + self->ConstructL( );
1.115 + CleanupStack::Pop(self);
1.116 +
1.117 + PRINT(_L("CMetaDataFileWriter::NewL() out"));
1.118 + return self;
1.119 + }
1.120 +
1.121 +
1.122 +// Destructor
1.123 +CMetaDataFileWriter::~CMetaDataFileWriter()
1.124 + {
1.125 + PRINT(_L("CMetaDataFileWriter::~CMetaDataFileWriter() in"));
1.126 +
1.127 +
1.128 + if ( IsActive() )
1.129 + {
1.130 + if ( iAsyncWritingOngoing )
1.131 + {
1.132 + Cancel();
1.133 + }
1.134 + else
1.135 + {
1.136 + TRequestStatus* status = &iStatus;
1.137 + User::RequestComplete( status, KErrNone );
1.138 + Cancel();
1.139 + }
1.140 + }
1.141 +
1.142 + iOutputFile.Reset();
1.143 + iInputBufferArray.ResetAndDestroy();
1.144 + iOutputBufferQueue.ResetAndDestroy();
1.145 + iEmptyBufferQueue.ResetAndDestroy();
1.146 + PRINT(_L("CMetaDataFileWriter::~CMetaDataFileWriter() out"));
1.147 + }
1.148 +
1.149 +// -----------------------------------------------------------------------------
1.150 +// CMetaDataFileWriter::Write( const TDesC8& aBuf )
1.151 +// Writes incoming buffer data to internal buffers for writing to disk.
1.152 +// (other items were commented in a header).
1.153 +// -----------------------------------------------------------------------------
1.154 +//
1.155 +TInt CMetaDataFileWriter:: Write( RFile64& aFile, const TInt aFileNumber, const TDesC8& aBuf )
1.156 + {
1.157 + PRINT(_L("CMetaDataFileWriter::Write() in"));
1.158 + PRINT((_L("e_cmetadatawriter_write 1")));
1.159 +
1.160 + iOutputFile[aFileNumber] = &aFile;
1.161 +
1.162 + PRINT((_L("e_cmetadatawriter_write_adddatatobuffer 1")));
1.163 + TInt error = AddDataToBuffer( aFileNumber, aBuf );
1.164 + if ( error != KErrNone )
1.165 + {
1.166 + PRINT((_L("CMetaDataFileWriter::Write() buffer write error: %d"), error));
1.167 + return error;
1.168 + }
1.169 + PRINT((_L("e_cmetadatawriter_write_adddatatobuffer 0")));
1.170 +
1.171 + PRINT((_L("CMetaDataFileWriter::Write() Write Buffer, Status: Full:%d Empty:%d "),
1.172 + iOutputBufferQueue.Count(), iEmptyBufferQueue.Count() ));
1.173 +
1.174 + if ( iAsyncWritingOngoing )
1.175 + {
1.176 + if ( iOutputBufferQueue.Count() >= KFileWriterHardBufLimit )
1.177 + {
1.178 + PRINT((_L("CMetaDataFileWriter::Write() Waiting async write to complete")));
1.179 + PRINT((_L("e_cmetadatawriter_write_waitasync 1")));
1.180 + User::WaitForRequest( iStatus );
1.181 + PRINT((_L("e_cmetadatawriter_write_waitasync 0")));
1.182 + PRINT((_L("CMetaDataFileWriter::Write() Async write done")));
1.183 + TRAP(error, RunL());
1.184 + if (error != KErrNone)
1.185 + {
1.186 + PRINT((_L("CMetaDataFileWriter::Write() runL leave, error: %d"), error));
1.187 + return error;
1.188 + }
1.189 + }
1.190 + }
1.191 + else
1.192 + {
1.193 + if ( iOutputBufferQueue.Count() )
1.194 + {
1.195 + PRINT(_L("CMetaDataFileWriter::Write() writing async"));
1.196 +
1.197 + PRINT((_L("e_cmetadatawriter_write_startwrite 1")));
1.198 +
1.199 + iOutputFile[iOutputBufferQueue[0]->iOutputFileNum]->Write( *(iOutputBufferQueue[0]->iData), iStatus );
1.200 + PRINT((_L("e_cmetadatawriter_write_startwrite 0")));
1.201 + iAsyncWritingOngoing = ETrue;
1.202 + if ( !IsActive() )
1.203 + {
1.204 + SetActive();
1.205 + }
1.206 + }
1.207 + }
1.208 +
1.209 + PRINT(_L("CMetaDataFileWriter::Write() out"));
1.210 + PRINT((_L("e_cmetadatawriter_write 0")));
1.211 + return error;
1.212 + }
1.213 +
1.214 +// -----------------------------------------------------------------------------
1.215 +// CMetaDataFileWriter::Flush( )
1.216 +// Flush internal buffers to disk.
1.217 +// (other items were commented in a header).
1.218 +// -----------------------------------------------------------------------------
1.219 +//
1.220 +TInt CMetaDataFileWriter::Flush( )
1.221 + {
1.222 + PRINT(_L("CMetaDataFileWriter::Flush() in"));
1.223 + PRINT((_L("e_cmetadatawriter_flush 1")));
1.224 + PRINT((_L("CMetaDataFileWriter::Flush() FullCount: %d "), iOutputBufferQueue.Count()));
1.225 +
1.226 + TInt error = KErrNone;
1.227 + iFlush = ETrue;
1.228 +
1.229 + if ( iAsyncWritingOngoing )
1.230 + {
1.231 + PRINT((_L("CMetaDataFileWriter::Flush() Waiting async write to complete")));
1.232 + PRINT((_L("e_cmetadatawriter_flush_waitasyncstop 1")));
1.233 + User::WaitForRequest( iStatus );
1.234 + PRINT((_L("e_cmetadatawriter_flush_waitasyncstop 0")));
1.235 + PRINT((_L("CMetaDataFileWriter::Flush() Async write done, flushing")));
1.236 + TRAP(error, RunL());
1.237 + if (error != KErrNone)
1.238 + {
1.239 + PRINT((_L("CMetaDataFileWriter::Flush() call runL leave, error: %d"), error));
1.240 + return error;
1.241 + }
1.242 + }
1.243 +
1.244 + while ( iOutputBufferQueue.Count() )
1.245 + {
1.246 + PRINT((_L("e_cmetadatawriter_flush_writesync 1")));
1.247 +
1.248 + error = iOutputFile[iOutputBufferQueue[0]->iOutputFileNum]->Write( *(iOutputBufferQueue[0]->iData) );
1.249 + if ( error == KErrNone )
1.250 + {
1.251 + error = iEmptyBufferQueue.Append(iOutputBufferQueue[0]);
1.252 + if (error == KErrNone)
1.253 + {
1.254 + iOutputBufferQueue[0]->iData->Des().Zero();
1.255 + iOutputBufferQueue[0]->iOutputFileNum = -1;
1.256 + iOutputBufferQueue.Remove(0);
1.257 + }
1.258 + else
1.259 + {
1.260 + PRINT((_L("CMetaDataFileWriter::Flush() iEmptyBufferQueue.Append failed, error: %d"), error));
1.261 + return error;
1.262 + }
1.263 + }
1.264 + else
1.265 + {
1.266 + PRINT((_L("CMetaDataFileWriter::Flush() fullBufQueue write failed, error: %d"), error));
1.267 + iFlush = EFalse;
1.268 + return error;
1.269 + }
1.270 + PRINT((_L("e_cmetadatawriter_flush_writesync 0")));
1.271 + }
1.272 +
1.273 + if ( !iFlushDone ) // Flush only once
1.274 + {
1.275 + iFlushDone = ETrue;
1.276 + for ( TInt i=0; i < KMetaDataWriterInputBufCount; i++ )
1.277 + {
1.278 + if ( iOutputFile[i] )
1.279 + {
1.280 + PRINT((_L("e_cmetadatawriter_flush_write_tempfiles 1")));
1.281 + error = iOutputFile[i]->Flush();
1.282 + PRINT((_L("e_cmetadatawriter_flush_write_tempfiles 0")));
1.283 + PRINT((_L("CMetaDataFileWriter::Flush() inputbuf[%d] flush return code: %d"), i, error));
1.284 + }
1.285 + }
1.286 + }
1.287 +
1.288 + iFlush = EFalse;
1.289 + PRINT((_L("CMetaDataFileWriter::Flush() FullCount: %d <= Should be 0"), iOutputBufferQueue.Count()));
1.290 + PRINT(_L("CMetaDataFileWriter::Flush() out"));
1.291 + PRINT((_L("e_cmetadatawriter_flush 0")));
1.292 + return KErrNone;
1.293 + }
1.294 +
1.295 +// -----------------------------------------------------------------------------
1.296 +// CMetaDataFileWriter::AddDataToBuffer( const TDesC8& aBuf )
1.297 +// Writes incoming data to internal buffers and buffer queues..
1.298 +// (other items were commented in a header).
1.299 +// -----------------------------------------------------------------------------
1.300 +//
1.301 +TInt CMetaDataFileWriter::AddDataToBuffer(const TInt aFileNumber, const TDesC8& aBuf )
1.302 + {
1.303 + PRINT(_L("CMetaDataFileWriter::AddDataToBuffer() in"));
1.304 +
1.305 + TInt byteswritten = 0;
1.306 + TInt numbytes = 0;
1.307 + TInt available = 0; // Available bytes in write buffer
1.308 + TInt error = KErrNone;
1.309 +
1.310 + HBufC8* inputBuf = iInputBufferArray[aFileNumber]->iData;
1.311 +
1.312 + if ( iError != KErrNone )
1.313 + {
1.314 + PRINT((_L("CMetaDataFileWriter::AddDataToBuffer() out, RunL iError: %d"), iError));
1.315 + return iError;
1.316 + }
1.317 +
1.318 + PRINT((_L("CMetaDataFileWriter::AddDataToBuffer() Save Buffer, Size: %d "), aBuf.Length() ));
1.319 +
1.320 + while (byteswritten < aBuf.Length() )
1.321 + {
1.322 + available = (inputBuf->Des()).MaxLength() - inputBuf->Length();
1.323 +
1.324 + if (available > 0)
1.325 + {
1.326 + numbytes = aBuf.Length() - byteswritten;
1.327 + if (numbytes > available)
1.328 + {
1.329 + numbytes = available;
1.330 + }
1.331 + inputBuf->Des().Append( aBuf.Mid( byteswritten, numbytes ) );
1.332 + byteswritten += numbytes;
1.333 + }
1.334 + else // Buffer is full, move it to outputqueue and use empty/new buf as input.
1.335 + {
1.336 + if ( iEmptyBufferQueue.Count() == 0 )
1.337 + {
1.338 + CMetaDataWriterBuffer* emptyInputBuffer = 0;
1.339 +
1.340 + emptyInputBuffer = new CMetaDataWriterBuffer;
1.341 + if ( !emptyInputBuffer )
1.342 + {
1.343 + PRINT((_L("CMetaDataFileWriter::AddDataToBuffer(), memory alloc failed")));
1.344 + iError = KErrNoMemory;
1.345 + break;
1.346 + }
1.347 +
1.348 + TRAP(error, emptyInputBuffer->iData = HBufC8::NewL( KMetaDataWriterBufferSize ));
1.349 + if ( error != KErrNone )
1.350 + {
1.351 + PRINT((_L("CMetaDataFileWriter::AddDataToBuffer(), memory alloc failed: %d"), error));
1.352 + delete emptyInputBuffer;
1.353 + emptyInputBuffer = NULL;
1.354 + iError = error;
1.355 + break;
1.356 + }
1.357 + else
1.358 + {
1.359 + error = iOutputBufferQueue.Append(iInputBufferArray[aFileNumber]);
1.360 + if (error != KErrNone)
1.361 + {
1.362 + PRINT((_L("CMetaDataFileWriter::AddDataToBuffer(), memory alloc failed: %d"), error));
1.363 + delete emptyInputBuffer;
1.364 + emptyInputBuffer = NULL;
1.365 + iError = error;
1.366 + break;
1.367 + }
1.368 +
1.369 + // old full buffer to output queue.
1.370 + emptyInputBuffer->iOutputFileNum = aFileNumber;
1.371 +
1.372 + // new buffer to input.
1.373 + iInputBufferArray[aFileNumber] = emptyInputBuffer;
1.374 + }
1.375 + }
1.376 + else
1.377 + {
1.378 + // old full buffer to output queue.
1.379 + TInt err = iOutputBufferQueue.Append( iInputBufferArray[aFileNumber] );
1.380 + if (err != KErrNone)
1.381 + {
1.382 + PRINT((_L("CMetaDataFileWriter::AddDataToBuffer(), iOutputBufferQueue.Append failed: %d"), err));
1.383 + iError = err;
1.384 + break;
1.385 + }
1.386 +
1.387 + // empty buffer from empty queue to input.
1.388 + iInputBufferArray[aFileNumber] = iEmptyBufferQueue[0];
1.389 + iInputBufferArray[aFileNumber]->iData->Des().Zero();
1.390 + iInputBufferArray[aFileNumber]->iOutputFileNum = aFileNumber;
1.391 + iEmptyBufferQueue.Remove(0);
1.392 + }
1.393 +
1.394 + inputBuf = iInputBufferArray[aFileNumber]->iData;
1.395 + }
1.396 + }
1.397 +
1.398 + PRINT((_L("CMetaDataFileWriter::AddDataToBuffer() out, error: %d"), error));
1.399 + return error;
1.400 + }
1.401 +
1.402 +// -----------------------------------------------------------------------------
1.403 +// CMetaDataFileWriter::DoCancel()
1.404 +// From CActive Cancels async request.
1.405 +// -----------------------------------------------------------------------------
1.406 +//
1.407 +void CMetaDataFileWriter::DoCancel()
1.408 + {
1.409 + }
1.410 +
1.411 +// -----------------------------------------------------------------------------
1.412 +// CMetaDataFileWriter::RunL()
1.413 +// From CActive Called when async request completes.
1.414 +// -----------------------------------------------------------------------------
1.415 +//
1.416 +void CMetaDataFileWriter::RunL()
1.417 + {
1.418 + PRINT(_L("CMetaDataFileWriter::RunL() in"));
1.419 + PRINT((_L("e_cmetadatawriter_runl 1")));
1.420 + iAsyncWritingOngoing = EFalse;
1.421 +
1.422 + if ( iStatus == KErrNone )
1.423 + {
1.424 + iEmptyBufferQueue.AppendL( iOutputBufferQueue[0] );
1.425 + iOutputBufferQueue[0]->iData->Des().Zero();
1.426 + iOutputBufferQueue[0]->iOutputFileNum = -1;
1.427 + iOutputBufferQueue.Remove( 0 );
1.428 + }
1.429 + else
1.430 + {
1.431 + PRINT((_L("CMetaDataFileWriter::RunL() Write error in previous async: %d "), iStatus.Int() ));
1.432 + iError = iStatus.Int();
1.433 + return;
1.434 + }
1.435 +
1.436 + PRINT((_L("CMetaDataFileWriter::RunL() Buffer written, Status: Full:%d Empty:%d "), iOutputBufferQueue.Count(), iEmptyBufferQueue.Count() ));
1.437 +
1.438 + if ( iFlush )
1.439 + {
1.440 + PRINT(_L("CMetaDataFileWriter::RunL() out, flushing"));
1.441 + PRINT((_L("e_cmetadatawriter_runl 0")));
1.442 + return;
1.443 + }
1.444 +
1.445 + if ( iOutputBufferQueue.Count() >= KFileWriterHardBufLimit )
1.446 + {
1.447 + while ( iOutputBufferQueue.Count() > KFileWriterSoftBufLimit )
1.448 + {
1.449 + PRINT((_L("e_cmetadatawriter_runl1_write 1")));
1.450 + iError = iOutputFile[iOutputBufferQueue[0]->iOutputFileNum]->Write( *(iOutputBufferQueue[0]->iData));
1.451 + PRINT((_L("e_cmetadatawriter_runl1_write 0")));
1.452 + if ( iError == KErrNone )
1.453 + {
1.454 + iEmptyBufferQueue.AppendL( iOutputBufferQueue[0] );
1.455 + iOutputBufferQueue[0]->iData->Des().Zero();
1.456 + iOutputBufferQueue[0]->iOutputFileNum = -1;
1.457 + iOutputBufferQueue.Remove( 0 );
1.458 + }
1.459 + else
1.460 + {
1.461 + PRINT((_L("CMetaDataFileWriter::RunL() Write error: %d "), iError));
1.462 + return;
1.463 + }
1.464 + }
1.465 + }
1.466 +
1.467 + if ( iOutputBufferQueue.Count() >= KFileWriterSoftBufLimit )
1.468 + {
1.469 + PRINT((_L("e_cmetadatawriter_runl2_write 1")));
1.470 + iError = iOutputFile[iOutputBufferQueue[0]->iOutputFileNum]->Write( *(iOutputBufferQueue[0]->iData));
1.471 + PRINT((_L("e_cmetadatawriter_runl2_write 0")));
1.472 + if ( iError == KErrNone )
1.473 + {
1.474 + iEmptyBufferQueue.AppendL( iOutputBufferQueue[0] );
1.475 + iOutputBufferQueue[0]->iData->Des().Zero();
1.476 + iOutputBufferQueue[0]->iOutputFileNum = -1;
1.477 + iOutputBufferQueue.Remove( 0 );
1.478 + }
1.479 + else
1.480 + {
1.481 + PRINT((_L("CMetaDataFileWriter::RunL() Write error: %d "), iError));
1.482 + return;
1.483 + }
1.484 + }
1.485 +
1.486 + if ( iOutputBufferQueue.Count() )
1.487 + {
1.488 + PRINT((_L("e_cmetadatawriter_runl3_write 1")));
1.489 + iOutputFile[iOutputBufferQueue[0]->iOutputFileNum]->Write( *(iOutputBufferQueue[0]->iData), iStatus );
1.490 + PRINT((_L("e_cmetadatawriter_runl3_write 0")));
1.491 + iAsyncWritingOngoing = ETrue;
1.492 + if ( !IsActive() )
1.493 + {
1.494 + SetActive();
1.495 + }
1.496 + }
1.497 +
1.498 + PRINT((_L("e_cmetadatawriter_runl 0")));
1.499 + PRINT(_L("CMetaDataFileWriter::RunL() out"));
1.500 + }
1.501 +
1.502 +// -----------------------------------------------------------------------------
1.503 +// CMetaDataFileWriter::RunError
1.504 +// -----------------------------------------------------------------------------
1.505 +//
1.506 + TInt CMetaDataFileWriter::RunError(TInt aError)
1.507 + {
1.508 + //RunL can leave.
1.509 + iError = aError;
1.510 + return KErrNone ;
1.511 + }
1.512 +
1.513 +// -----------------------------------------------------------------------------
1.514 +// CMetaDataFileWriter::ReadBuffer
1.515 +// -----------------------------------------------------------------------------
1.516 +//
1.517 +TInt CMetaDataFileWriter::ReadBuffer( const TInt aFileNumber, TDes8& aBuf, TInt bytestoread )
1.518 + {
1.519 + PRINT(_L("CMetaDataFileWriter::ReadBuffer() in"));
1.520 + PRINT((_L("e_cmetadatawriter_readbuffer 1")));
1.521 + TInt bytesread;
1.522 +
1.523 + PRINT((_L("CMetaDataFileWriter::ReadBuffer() iInputBufferArray[%d]->iData->Length(): %d, requested %d"), aFileNumber, iInputBufferArray[aFileNumber]->iData->Length(), bytestoread));
1.524 + if ( !iInputBufferArray[aFileNumber]->iData->Length() )
1.525 + {
1.526 + bytesread = 0;
1.527 + }
1.528 + else if ( (iInputBufferArray[aFileNumber]->iData->Length() -
1.529 + iInputBufferArrayDelivered[aFileNumber]) >= bytestoread )
1.530 + {
1.531 + bytesread = bytestoread;
1.532 + aBuf.Append( iInputBufferArray[aFileNumber]->iData->Mid( iInputBufferArrayDelivered[aFileNumber], bytesread ) );
1.533 + iInputBufferArrayDelivered[aFileNumber] += bytesread;
1.534 +
1.535 + // If the buffer is read empty, release it
1.536 + if ( iInputBufferArray[aFileNumber]->iData->Length() == iInputBufferArrayDelivered[aFileNumber] )
1.537 + {
1.538 + PRINT((_L("CMetaDataFileWriter::ReadBuffer() iInputBufferArray[%d] %d delivered"), aFileNumber, iInputBufferArray[aFileNumber]->iData->Length()));
1.539 + iInputBufferArray[aFileNumber]->iData->Des().Zero();
1.540 + }
1.541 + }
1.542 + else
1.543 + {
1.544 + bytesread = iInputBufferArray[aFileNumber]->iData->Length() - iInputBufferArrayDelivered[aFileNumber];
1.545 + aBuf.Append( iInputBufferArray[aFileNumber]->iData->Mid( iInputBufferArrayDelivered[aFileNumber], bytesread ) );
1.546 + iInputBufferArrayDelivered[aFileNumber] += bytesread;
1.547 +
1.548 + PRINT((_L("CMetaDataFileWriter::ReadBuffer() iInputBufferArray[%d] %d bytes delivered"), aFileNumber, iInputBufferArray[aFileNumber]->iData->Length()));
1.549 + iInputBufferArray[aFileNumber]->iData->Des().Zero();
1.550 + }
1.551 +
1.552 + PRINT((_L("e_cmetadatawriter_readbuffer 0")));
1.553 + PRINT(_L("CMetaDataFileWriter::ReadBuffer() out"));
1.554 +
1.555 + return ( bytesread );
1.556 + }
1.557 +
1.558 +// End of File