workbench/libs/iffparse/bufferingfuncs.c

   1 /*
   2     Copyright © 1995-2004, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Funtions needed for buffering writes.
   6 */
   7 #include "iffparse_intern.h"
   8
   9
  10
  11 /****************/
  12 /* AllocBuffer  */
  13 /****************/
  14
  15 struct BufferList *AllocBuffer(ULONG bufnodesize,
  16     struct IFFParseBase_intern * IFFParseBase)
  17 {
  18     struct BufferList *buflist;
  19     struct BufferNode *bufnode;
  20
  21     DEBUG_ALLOCBUFFER(dprintf("AllocBuffer: bufnodesize 0x%lx\n", bufnodesize));
  22
  23     /* First allocate memory for the BufferList structure */
  24
  25     buflist = AllocMem(sizeof (struct BufferList), MEMF_ANY);
  26
  27     if (buflist)
  28     {
  29         /* Initialize teh bufferlist */
  30         NewList( (struct List*)&(buflist->bl_ListHeader) );
  31         buflist->bl_BufferNodeSize = bufnodesize;
  32
  33
  34         /* The bufferlist should always contain at least one buffer */
  35
  36         bufnode = AllocBufferNode(buflist, IFFParseBase);
  37
  38         if (bufnode)
  39         {
  40             buflist->bl_CurrentNode      = bufnode;
  41             buflist->bl_CurrentOffset    =  0;
  42             buflist->bl_BufferSize      =  0;
  43             buflist->bl_CurrentNodeNum  = 1;
  44
  45             DEBUG_ALLOCBUFFER(dprintf("AllocBuffer: return %p\n", buflist));
  46             return (buflist);
  47         }
  48
  49         FreeMem(buflist, sizeof (struct BufferList) );
  50     }
  51
  52     DEBUG_ALLOCBUFFER(dprintf("AllocBuffer: return NULL\n"));
  53     return NULL;
  54 }
  55
  56
  57 /**************/
  58 /* FreeBuffer  */
  59 /**************/
  60
  61 /* Frees all the buffers and buffernodes inside a bufferlist */
  62
  63 VOID FreeBuffer(struct BufferList *buflist,
  64     struct IFFParseBase_intern * IFFParseBase)
  65 {
  66     /* Frees all the buffernodes in a bufferlist */
  67     struct BufferNode *node, *nextnode;
  68
  69     /* first free all the nodes */
  70
  71     node = (struct BufferNode*)buflist->bl_ListHeader.mlh_Head;
  72
  73     while ((nextnode=(struct BufferNode*)node->bn_Node.mln_Succ))
  74     {
  75
  76         FreeMem(node->bn_BufferPtr, buflist->bl_BufferNodeSize);
  77
  78         FreeMem(node,sizeof(struct BufferNode));
  79         node = nextnode;
  80     }
  81
  82     /* Free the bufferlist itself */
  83
  84     FreeMem(buflist, sizeof (struct BufferList));
  85     return;
  86 }
  87
  88
  89 /********************/
  90 /* AllocBufferNode  */
  91 /********************/
  92
  93 /* Allocate a new buffernode,
  94   a new buffer, and add the buffernode to the TAIL of the bufferlist
  95 */
  96 struct BufferNode *AllocBufferNode(struct BufferList *buflist,
  97     struct IFFParseBase_intern * IFFParseBase)
  98 {
  99     /* New buffernodes are added at the HEAD of the list */
 100
 101     struct BufferNode *n;
 102
 103     DEBUG_ALLOCBUFFER(dprintf("AllocBufferNode: buflist %p\n", buflist));
 104
 105     /* first allocate node */
 106     if ((n=(struct BufferNode*)AllocMem(sizeof(struct BufferNode),MEMF_ANY)))
 107     {
 108         /* Then allocate buffer */
 109         if ((n->bn_BufferPtr=(UBYTE*)AllocMem(buflist->bl_BufferNodeSize, MEMF_ANY)))
 110         {
 111             AddTail((struct List*)buflist,(struct Node*)n);
 112
 113             DEBUG_ALLOCBUFFER(dprintf("AllocBufferNode: return %p\n", n));
 114             return (n);
 115         }
 116
 117         FreeMem(n,sizeof(struct BufferNode));
 118     }
 119
 120     DEBUG_ALLOCBUFFER(dprintf("AllocBufferNode: return NULL\n"));
 121     return NULL;
 122 }
 123
 124 /********************/
 125 /* WriteToBuffer    */
 126 /********************/
 127
 128 /* Copies a number of bytes into the buffer at the current position */
 129
 130 LONG WriteToBuffer( struct BufferList *buflist, UBYTE *mem, LONG size,
 131     struct IFFParseBase_intern * IFFParseBase)
 132 {
 133     /* The buffernode that the routine currently will buffer to */
 134     struct BufferNode *bufnode;
 135
 136
 137     /* Total number of bytes to be written */
 138     ULONG   bytes2write;
 139
 140     /* Bytes left in bufnode that may be written into */
 141     ULONG  bytesleft;
 142           /* The offset int bufnode that the routine will start buffering at */
 143     ULONG  bufoffset;
 144
 145     ULONG  bufnodenum;
 146     /*
 147       This is the offset in bytes into the whole buffer, not obly into the
 148       current node
 149     */
 150     ULONG offset_into_bigbuf;
 151
 152
 153     DEBUG_WRITETOBUFFER(dprintf("WriteToBuffer: buflist %p mem %p size %ld\n", buflist, mem, size));
 154
 155     bytes2write = size;
 156
 157     /* Get pointer to current buffer in list */
 158     bufnode   = buflist->bl_CurrentNode;
 159     bufoffset  = buflist->bl_CurrentOffset;
 160
 161     bufnodenum = buflist->bl_CurrentNodeNum;
 162
 163     /* Calculate the offset into the buffer as a whole */
 164     offset_into_bigbuf  =  (bufnodenum  - 1) * buflist->bl_BufferNodeSize + bufoffset;
 165
 166     while (bytes2write)
 167     {
 168
 169         /* Find out how many bytes we can write into the current node */
 170
 171         bytesleft = buflist->bl_BufferNodeSize - bufoffset;
 172
 173
 174         if (bytes2write > bytesleft)
 175         {
 176             /* Copy into the old buffer all that there is place for */
 177             CopyMem(mem,bufnode->bn_BufferPtr + bufoffset, bytesleft);
 178
 179             /* We have written bytesleft bytes */
 180             bytes2write -= bytesleft;
 181             mem += bytesleft;
 182
 183             /* No more space in this buffernode */
 184             bytesleft = 0;
 185
 186             /* Go to the next buffer in the list */
 187             bufnode = (struct BufferNode*)bufnode->bn_Node.mln_Succ;
 188
 189             bufnodenum ++;
 190             /* We go to the start of the current buffernode */
 191             bufoffset = 0;
 192
 193             if (!bufnode->bn_Node.mln_Succ)
 194             {
 195                 /* No more nodes in the list.   We have to allocate and add a new one */
 196
 197
 198                 bufnode = AllocBufferNode(buflist, IFFParseBase);
 199
 200                 /* Did the allocation succeed ? */
 201                 if (!bufnode)
 202                 {
 203                     /* Return number of bytes written so far */
 204                     DEBUG_WRITETOBUFFER(dprintf("WriteToBuffer: return %ld\n", (size - bytes2write)));
 205                     return (size - bytes2write);
 206                 }
 207             }
 208
 209         }
 210         else
 211         {
 212             /* There is place enough to write the remaining bytes into the current buffer */
 213             CopyMem
 214             (
 215                 mem,
 216                 bufnode->bn_BufferPtr + bufoffset,
 217                 bytes2write
 218             );
 219
 220             bufoffset             += bytes2write;
 221
 222             bytes2write         =   0;
 223         }
 224
 225     }  /* End of while */
 226
 227     /* If we have reached here, we can be sure that bytes written == size
 228        (everything has been succesfull) */
 229
 230     /* Update some stuff */
 231     buflist->bl_CurrentNode      = bufnode;
 232     buflist->bl_CurrentOffset    = bufoffset;
 233     buflist->bl_CurrentNodeNum   = bufnodenum;
 234
 235     /* Update the offset into buffer as a whole */
 236     offset_into_bigbuf  += size;
 237
 238     /* Have we expanded the buffer ? */
 239     if (offset_into_bigbuf > buflist->bl_BufferSize)
 240          /* Update the size of the buffer */
 241          buflist->bl_BufferSize = offset_into_bigbuf;
 242
 243     DEBUG_WRITETOBUFFER(dprintf("WriteToBuffer: return %ld\n", size));
 244     return (size);
 245 }
 246
 247 /****************/
 248 /* SeekBuffer    */
 249 /****************/
 250
 251
 252 BOOL SeekBuffer
 253 (
 254     struct BufferList *buflist,
 255     LONG offset
 256
 257 )
 258 {
 259     struct BufferNode *bufnode;
 260
 261     /*  The number of bytes we potentially can seek in this buffernode's buffer
 262     */
 263     ULONG  left2seekinbuf,
 264           /* The size of each buffer. (same for all buffers) */
 265           bufnodesize,
 266           bufoffset,
 267           bufnodenum;
 268
 269     LONG offset_into_bigbuf,
 270           new_offset_into_bigbuf;
 271
 272     DEBUG_SEEKBUFFER(dprintf("WriteToBuffer: buflist %p offset %ld\n", buflist, offset));
 273
 274     /* Get the size of the buffers */
 275     bufnodesize  = buflist->bl_BufferNodeSize;
 276     bufnode      = buflist->bl_CurrentNode;
 277     bufoffset   = buflist->bl_CurrentOffset;
 278     bufnodenum  = buflist->bl_CurrentNodeNum;
 279
 280     offset_into_bigbuf  =  (bufnodenum - 1) * bufnodesize + bufoffset;
 281
 282     /* Calculate the new offset into whole buffer. Remember: If the offset is negative,
 283        this will be substarction.*/
 284     new_offset_into_bigbuf = offset_into_bigbuf + offset;
 285
 286     /* Are we seeking forwards, backwords or not at all ? */
 287     if (offset > 0)
 288     {
 289         /* Forwards seek */
 290
 291         /* Are we trying to seek outside the bounds of the buffer */
 292         if (new_offset_into_bigbuf > buflist->bl_BufferSize)
 293         {
 294             DEBUG_SEEKBUFFER(dprintf("WriteToBuffer: return FALSE #1\n"));
 295             return (FALSE);
 296         }
 297
 298         /* How much is there left to seek towards the end of the first buf ? */
 299         left2seekinbuf  = bufnodesize - bufoffset;
 300
 301         while (offset) /* While there are more bytes to seek */
 302         {
 303             if (offset > left2seekinbuf)
 304             {
 305                 /* We have to jump to the next buffer in the list */
 306                 bufnode = (struct BufferNode*)bufnode->bn_Node.mln_Succ;
 307
 308 #if 0
 309                 if (!bufnode->bn_Node.mln_Succ)
 310                 {
 311                     /* Oops !! No more buffers to seek in */
 312                     DEBUG_SEEKBUFFER(dprintf("WriteToBuffer: return FALSE #2\n"));
 313                     return (FALSE);
 314                 }
 315 #endif
 316
 317                 offset -= left2seekinbuf;
 318                 bufnodenum ++;
 319
 320                 /* Current offset is at start of the buffer */
 321                 bufoffset  =  0;
 322
 323                 /* The number of bytes written to this buffer
 324                 is the number we can potentially seek.
 325                  */
 326                 left2seekinbuf = bufnodesize;
 327
 328             }
 329             else
 330             {
 331                 /* We are at the last buffernode we have to seek. */
 332                 bufoffset += offset;
 333
 334                 /* not more to seek */
 335                 offset   = 0;
 336             }
 337         }  /* End of while */
 338     }
 339
 340     else if (offset < 0)
 341     {
 342
 343         /* Backwards seek */
 344
 345         /* Are we trying to seek outside the bounds of the buffer */
 346         if (new_offset_into_bigbuf < 0)
 347         {
 348             DEBUG_SEEKBUFFER(dprintf("WriteToBuffer: return FALSE #3\n"));
 349             return (FALSE);
 350         }
 351
 352         /* For simplicity we take the absolute value of offset */
 353         offset = abs(offset);
 354
 355         /* How much is there left to seek towards the start of the first buf ? */
 356         left2seekinbuf  = bufoffset;
 357
 358         while (offset) /* While there are more bytes to seek */
 359         {
 360             if (offset > left2seekinbuf)
 361             {
 362
 363                 /* We have to jump to the next buffer in the list */
 364                 bufnode = (struct BufferNode*)bufnode->bn_Node.mln_Pred;
 365
 366 #if 0
 367                 if (bufnode->bn_Node.mln_Pred == NULL )
 368                 {
 369                     /* Oops !! No more buffers to seek in */
 370                     DEBUG_SEEKBUFFER(dprintf("WriteToBuffer: return FALSE #4\n"));
 371                     return (FALSE);
 372                 }
 373 #endif
 374
 375                 offset -= left2seekinbuf;
 376                 bufnodenum --;
 377
 378                 /* Current offset is at end of the buffer */
 379                 bufoffset  =  bufnodesize;
 380
 381                 /* The number of bytes written to this buffer
 382                 is the number we can potentially seek.
 383                  */
 384                 left2seekinbuf = bufoffset;
 385
 386             }
 387             else
 388             {
 389                 /* We are at the last buffernode we have to seek. */
 390                 bufoffset -= offset;
 391                 offset    = 0;
 392
 393                 /* not more to seek */
 394
 395             }
 396         }  /* End of while */
 397     }
 398
 399     /* if offset is 0, we are finished seeking */
 400
 401     buflist->bl_CurrentNode     = bufnode;
 402     buflist->bl_CurrentOffset    = bufoffset;
 403     buflist->bl_CurrentNodeNum  = bufnodenum;
 404
 405     DEBUG_SEEKBUFFER(dprintf("WriteToBuffer: return TRUE\n"));
 406     return (TRUE);
 407 }
 408
 409 /******************/
 410 /* BufferToStream  */
 411 /******************/
 412
 413 /* Writes a whole buffer to a stream.
 414 It is VERY important that intiff->BufferStartDepth is 0, when this
 415 function is called. Else, WriteStream will buffer the writes, and we will
 416 get a nice loop allocating ALL the memory of the machine. (imagine that with VM ;-)
 417
 418 Well, I guess I'll set that to 0 at the start of this function, just for safety.
 419
 420 */
 421
 422 BOOL BufferToStream
 423 (
 424     struct BufferList *buflist,
 425     struct IFFHandle   *iff,
 426     struct IFFParseBase_intern * IFFParseBase
 427 )
 428 {
 429     struct BufferNode *node,
 430                       *nextnode;
 431
 432
 433     /* Number of bytes axtually writen to the stream,
 434       or if negative: an IFFERR_.. error */
 435
 436     LONG   byteswritten = 0,
 437           bytes2write,
 438           numbytes;
 439
 440
 441     DEBUG_BUFFERTOSTREAM(dprintf("BufferToStream: buflist %p iff %p\n", buflist, iff));
 442
 443     numbytes = buflist->bl_BufferSize;
 444     /* For safety. Read at the function header. */
 445     GetIntIH(iff)->iff_BufferStartDepth = 0;
 446
 447     nextnode = (struct BufferNode*)buflist->bl_ListHeader.mlh_Head;
 448
 449     while (numbytes)
 450     {
 451         node = nextnode;
 452
 453         /* Should we write more than the first buffer ? */
 454
 455         if (numbytes > buflist->bl_BufferNodeSize)
 456         {
 457
 458             nextnode = (struct BufferNode*)node->bn_Node.mln_Succ;
 459             /* Check if there are enough buffers to write numbytesf */
 460             if (!nextnode)
 461             {
 462                 DEBUG_BUFFERTOSTREAM(dprintf("BufferToStream: return FALSE #1\n"));
 463                 return (FALSE);
 464             }
 465
 466
 467             bytes2write = buflist->bl_BufferNodeSize;
 468
 469         }
 470         else
 471         {
 472             /* We are at the last buffer to write */
 473
 474             bytes2write = numbytes;
 475         }
 476
 477         /* Write a buffernode to the stream */
 478         byteswritten = WriteStream
 479         (
 480             iff,
 481             node->bn_BufferPtr,
 482             bytes2write,
 483             IFFParseBase
 484         );
 485
 486         /* Do we have a IFFERR_.. ? */
 487         if (byteswritten < 0)
 488         {
 489             DEBUG_BUFFERTOSTREAM(dprintf("BufferToStream: return FALSE #2\n"));
 490             return (FALSE);
 491         }
 492
 493
 494         /* There is bytes2write less to write */
 495
 496         numbytes -= bytes2write;
 497     }
 498
 499
 500     DEBUG_BUFFERTOSTREAM(dprintf("BufferToStream: return %ld\n", byteswritten));
 501     return (byteswritten);
 502 }
 503
 504 /*****************************************/
 505 /* BufferStream initialization & cleanup */
 506 /*****************************************/
 507
 508 /* Put in own functions just to make code tidier */
 509
 510 LONG  InitBufferedStream(struct IFFHandle *iff,
 511     struct IFFParseBase_intern * IFFParseBase)
 512 {
 513     DEBUG_INITBUFFEREDSTREAM(dprintf("InitBufferedStream: iff %p\n", iff));
 514
 515     if
 516     (
 517         !(GetIntIH(iff)->iff_BufferStartDepth)
 518     )
 519     {
 520         /* Preserve the stream */
 521         GetIntIH(iff)->iff_PreservedStream = iff->iff_Stream;
 522
 523         /* Allocate buffers that WriteStream can buffer its output to */
 524         if (!( iff->iff_Stream = (IPTR)AllocBuffer(BUFFERNODESIZE, IFFParseBase)))
 525         {
 526             DEBUG_INITBUFFEREDSTREAM(dprintf("InitBufferedStream: return IFFERR_NOMEM\n"));
 527             return (IFFERR_NOMEM);
 528         }
 529
 530         /* To inform WriteStream that it should buffer all input */
 531         /* + 1 because we have not PushContextNode()ed yet */
 532
 533         GetIntIH(iff)->iff_BufferStartDepth = iff->iff_Depth + 1;
 534
 535         /* Preserve the old hook and the old flags */
 536
 537         GetIntIH(iff)->iff_PreservedHandler = GetIntIH(iff)->iff_StreamHandler;
 538
 539
 540         GetIntIH(iff)->iff_PreservedFlags = iff->iff_Flags;
 541
 542
 543         /* Insert the BufStreamHandler into the hook instead */
 544         InitIFF(iff, IFFF_RSEEK, &IFFParseBase->bufhook);
 545
 546     }
 547
 548     DEBUG_INITBUFFEREDSTREAM(dprintf("InitBufferedStream: return 0\n"));
 549     return 0;
 550 }
 551
 552 LONG ExitBufferedStream(struct IFFHandle *iff,
 553     struct IFFParseBase_intern * IFFParseBase)
 554 {
 555     /*
 556       If we have come to the chunk that started internal buffering, then we should do the following.
 557
 558             - Turn it off, so that WriteStream again writes to the REAL stream.
 559             - Write the whole buffer to this stream.
 560             - Free the buffer/
 561     */
 562     LONG err = 0;
 563
 564     struct BufferList *buflist;
 565
 566     DEBUG_EXITBUFFEREDSTREAM(dprintf("ExitBufferedStream: iff %p\n", iff));
 567
 568     /* Turn off buffering */
 569     GetIntIH(iff)->iff_BufferStartDepth = 0;
 570
 571       /* Read out the bufferlist stream pointer */
 572     buflist = (struct BufferList*)iff->iff_Stream;
 573
 574
 575     /* Now we can reinstall the old StreamHandler */
 576     GetIntIH(iff)->iff_StreamHandler =   GetIntIH(iff)->iff_PreservedHandler;
 577
 578     /* Reinstall the old flags */
 579     iff->iff_Flags = GetIntIH(iff)->iff_PreservedFlags;
 580
 581
 582     /* Reinstall the old stream */
 583     iff->iff_Stream = GetIntIH(iff)->iff_PreservedStream;
 584
 585
 586     /* Write all the buffers into the old stream */
 587     if (!BufferToStream(buflist,
 588                         iff,
 589                         IFFParseBase))
 590     {
 591         err = IFFERR_WRITE;
 592     }
 593
 594     FreeBuffer(buflist, IFFParseBase);
 595
 596     DEBUG_EXITBUFFEREDSTREAM(dprintf("ExitBufferedStream: return %ld\n", err));
 597     return (err);
 598 }
 599
 600 /**********************/
 601 /* BufStreamHandler    */
 602 /**********************/
 603
 604 #define IFFParseBase        (IPB(hook->h_Data))
 605
 606 ULONG BufStreamHandler
 607 (
 608     struct Hook         *hook,
 609     struct IFFHandle    *iff,
 610     struct IFFStreamCmd  *cmd
 611 )
 612 {
 613
 614     ULONG error = 0;
 615
 616     DEBUG_BUFSTREAMHANDLER(dprintf("BufStreamHandler: hook %p iff %p cmd %p\n", hook, iff, cmd));
 617
 618     switch (cmd->sc_Command)
 619     {
 620
 621         case IFFCMD_READ:
 622
 623             DEBUG_BUFSTREAMHANDLER(dprintf("BufStreamHandler: IFFCMD_READ...\n"));
 624
 625             /* It should NEVER be needed to read a buffered stream.
 626               To output the buffered stream to the real stream,
 627               we have the routne BufferToStream which is MUCH more effective
 628             */
 629
 630             error = 1;
 631             break;
 632
 633         case IFFCMD_WRITE:
 634
 635             DEBUG_BUFSTREAMHANDLER(dprintf("BufStreamHandler: IFFCMD_WRITE...\n"));
 636
 637             error =
 638             (
 639                 WriteToBuffer
 640                 (
 641                     (struct BufferList*)iff->iff_Stream,
 642                     cmd->sc_Buf,
 643                     cmd->sc_NBytes,
 644                     IFFParseBase
 645                 )
 646             !=
 647                 cmd->sc_NBytes
 648             );
 649
 650             break;
 651
 652         case IFFCMD_SEEK:
 653
 654             DEBUG_BUFSTREAMHANDLER(dprintf("BufStreamHandler: IFFCMD_SEEK...\n"));
 655
 656             error =
 657             (!
 658                 SeekBuffer
 659                 (
 660                     (struct BufferList*)iff->iff_Stream,
 661                     cmd->sc_NBytes
 662                 )
 663             );
 664
 665             break;
 666
 667         case IFFCMD_INIT:
 668         case IFFCMD_CLEANUP:
 669
 670             DEBUG_BUFSTREAMHANDLER(dprintf("BufStreamHandler: IFFCMD_INIT/IFFCMD_CLEANUP...\n"));
 671
 672             error = 0;
 673             break;
 674
 675     }
 676
 677     DEBUG_BUFSTREAMHANDLER(dprintf("BufStreamHandler: return %ld\n", error));
 678     return (error);
 679 }
 680