void CRecorderAdapter::AddBlankSecondL()
{
   // In order to read in data in the correct littleEndian fashion,
   // we have our own cool little class. This code will not compile
   // for you but bear in mind that when you read in bytes from a
   // file you have to make sure they are interpreted correctly before
   // blindly casting to your type. Anyway, the point is the class used
   // here CIntelDataReadBuffer is not something you will find in the SDK
   CIntelDataReadBuffer* reader = CIntelDataReadBuffer::NewL(100);
   CleanupStack::PushL(reader);
   RFs fs = CCoeEnv::Static()->FsSession();
   RFile file;
   TInt ret1 = file.Open(fs, iNewFileName, EFileWrite);
   if (ret1 == KErrNone)
   {
       CleanupClosePushL(file);
       TBuf8<4> sizeBuf;

       TBuf8<4> id; //four bytes to hold 'RIFF'
       file.Read(id); //read in first four bytes
       if (id.Compare(_L8("RIFF")) == 0)
       { //we had 'RIFF' let's continue
           //we want the size to be 4k bigger than it was
           //so take the size of the file, add 4k then take
           //off 8 for the RIFF and length of the int
           TInt fileSize = 0;
           file.Size(fileSize);

           TInt newSize = fileSize + (4096 - 8);

           // now you have to do a little bit of magic to write an int (4 bytes)
           // into a buffer in the correct littleEndian format. This is left as
           // an exercise for the reader! We have our own little class for it:
           // our class is CIntelDataWriteBuffer so obviously this won't
           // compile for you...
           CIntelDataWriteBuffer* writer = CIntelDataWriteBuffer::NewL(4);
           CleanupStack::PushL(writer);
           writer->WriteIntL(newSize);

           HBufC8* buffer = writer->GetBufferL(); // Passes ownership
           CleanupStack::PushL(buffer);
           file.Write(*buffer, 4);
           CleanupStack::PopAndDestroy(); //buffer
           CleanupStack::PopAndDestroy(); //writer

           //read in 4 byte string now
           file.Read(id); //read in next four bytes
           if (id.Compare(_L8("WAVE")) == 0)
           { //this is probably a wave file since it contained "WAVE"
               file.Read(id); //read in 4 bytes "fmt "; (I think)

               //now we need to loop through until we find the "data"
               //block - the general structure is 4 bytes name, 4 bytes
               //length and then the length bytes of stuff.
               //It turns out the files recorded on Symbian seem to have
               //the data length wrong, so we also need to find the "data"
               //block and then adjust the length
               while (id.Compare(_L8("data")) != 0)
               {
                   file.Read(sizeBuf); //this is the length
                   // using our magic reader class
                   reader->Reset();
                   reader->AddDataL(sizeBuf);
                   TInt32 length = 0;
                   reader->ReadInt(length);
                   //this seek should take us to the end of the block
                   TInt lengthInt = length;
                   file.Seek(ESeekCurrent, lengthInt);

                   file.Read(id);
               }
               //when we get here we must have found the "data" block
               //so now read the length of the block (as given)
               file.Read(sizeBuf); //this is the length
               reader->Reset();
               reader->AddDataL(sizeBuf);
               TInt32 dataLength = 0;
               reader->ReadInt(dataLength);
               TInt pos = -4;
               file.Seek(ESeekCurrent, pos);
               //now pos should contain the pos of the length
               //our length should be set to the size of the file
               // plus 4K minus (this pos plus four)
               TInt newDataLength = fileSize + 4096 - (pos + 4);

               writer = CIntelDataWriteBuffer::NewL(4);
               CleanupStack::PushL(writer);
               writer->WriteIntL(newDataLength);

               buffer = writer->GetBufferL(); // Passes ownership
               CleanupStack::PushL(buffer);
               file.Write(*buffer, 4);
               CleanupStack::PopAndDestroy(); //buffer
               CleanupStack::PopAndDestroy(); //writer

               //now we have to add that 4K of data
               //now go to end
               pos = 0;
               file.Seek(ESeekEnd, pos);

               writer = CIntelDataWriteBuffer::NewL(4096);
               CleanupStack::PushL(writer);
               //fill the buffer with 4k blanks
               for (TInt i = 0; i < 1024; i++)
               {
                 writer->WriteIntL(0);
               }

               buffer = writer->GetBufferL(); // Passes ownership
               CleanupStack::PushL(buffer);
               /*TInt ret = */file.Write(*buffer, 4096);
               CleanupStack::PopAndDestroy(); //buffer
               CleanupStack::PopAndDestroy(); //writer


               file.Flush();
           }
           else
           {
                 DoLog(_L("Error: RIFF file but not a wave file"));
           }
       }
       else
       {
             DoLog(_L("Error: not a RIFF file"));
       }
       //instead of this
       //file.Close();
       //do this
       CleanupStack::PopAndDestroy(); //file.Close()
   }
   CleanupStack::PopAndDestroy(); //reader
}