workbench/libs/iffparse/popchunk.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include "iffparse_intern.h"
   7
   8 /*****************************************************************************
   9
  10     NAME */
  11 #include <proto/iffparse.h>
  12
  13         AROS_LH1(LONG, PopChunk,
  14
  15 /*  SYNOPSIS */
  16         AROS_LHA(struct IFFHandle *, iff, A0),
  17
  18 /*  LOCATION */
  19         struct Library *, IFFParseBase, 15, IFFParse)
  20
  21 /*  FUNCTION
  22         Pops a context node of the context stack. Usually called
  23         in write mode to signal the end of a chunk.
  24
  25
  26     INPUTS
  27         iff    - pointer to IFFHandle struct.
  28
  29     RESULT
  30         error  -  0 if successfull, IFFERR_#? otherwise.
  31
  32     NOTES
  33
  34     EXAMPLE
  35
  36     BUGS
  37
  38     SEE ALSO
  39         PushChunk()
  40
  41     INTERNALS
  42
  43     Frees a contextnode an all its related LCIs and removes it from the stack-list
  44     If we are in write mode, we will update the cn_Size in the chunk according
  45     t cn_Scan, and we will also insert an align byte if necessary
  46
  47
  48     If the stream was of PushChunked() as IFFSIZE_UNKNOWN, we have to seek backwards
  49     and write the correct size.
  50     Since non RSEEK streams are automagically buffered by
  51     WriteStream, we don't have to fiddle with it here.
  52     However if the stream is buffered, we MUST see if we are
  53     about to pop the chunk that started the Buffering (in PushChunk)
  54
  55 *****************************************************************************/
  56 {
  57     AROS_LIBFUNC_INIT
  58
  59     struct ContextNode  *cn;
  60
  61     LONG err;
  62
  63     LONG size;
  64
  65     UBYTE nullbyte = 0;
  66
  67     DEBUG_POPCHUNK(dprintf("PopChunk: iff 0x%lx\n", iff));
  68
  69     /* Get current chunk */
  70     cn = TopChunk(iff);
  71
  72     /* Is the IFFHandle opened in Read or Write mode ? */
  73     if (iff->iff_Flags & IFFF_WRITE)
  74     {
  75         /* Write mode. We should update cn_Size *INSIDE the stream,
  76         if the chunk was pushed with IFFSIZE_UNKNOWN */
  77
  78         if (cn->cn_Size == IFFSIZE_UNKNOWN)
  79         {
  80
  81             err = SeekStream
  82             (
  83                 iff,
  84                 /* minus is for seeking backwards. Remember: evt. chunk types
  85                 for composite chunks are allready in cn_Scan */
  86                 - ( cn->cn_Scan + sizeof(ULONG) ),
  87                 IPB(IFFParseBase)
  88             );
  89
  90             if (err) return (err);
  91
  92             size = cn->cn_Scan;
  93
  94             /* Write the chunk size */
  95             err = WriteStreamLong
  96             (
  97                 iff,
  98                 &size,
  99                 IPB(IFFParseBase)
 100             );
 101
 102             if (err < 0) return (err);
 103
 104             /* Seek towards end of chunk again */
 105             err = SeekStream
 106             (
 107                 iff,
 108                 size,
 109                 IPB(IFFParseBase)
 110             );
 111
 112             if (err) return (err);
 113
 114         }
 115         else  /* IFFSIZE known at PushChunk() time */
 116             size = cn->cn_Size;
 117
 118
 119         /* Write a pad byte if chunk is not word-aligned */
 120         if (size % 2)
 121         {
 122             err =  WriteStream
 123             (
 124                 iff,
 125                 &nullbyte,
 126                 1,
 127                 IPB(IFFParseBase)
 128             );
 129
 130             if (err < 0) return (err);
 131             size++;
 132         }
 133
 134         if
 135         (
 136             GetIntIH(iff)->iff_BufferStartDepth
 137         ==
 138             iff->iff_Depth
 139         )
 140         {
 141             /* a routine that writes the buffer to stream and reinstallss the old streamhandler */
 142
 143             err = ExitBufferedStream(iff, IPB(IFFParseBase));
 144             if (err) return (err);
 145
 146         }
 147     }
 148
 149     /* Actually pop the top context-node. (Done for both handles in Read & Write mode) */
 150
 151     PopContextNode(iff, IPB(IFFParseBase));
 152
 153     /* stegerg: is this okay!? */
 154
 155     if (iff->iff_Flags & IFFF_WRITE)
 156     {
 157         cn = TopChunk(iff);
 158
 159         /* Might work without this check, because there seems to be always at
 160            least one contextnode --> see AllocIFF) */
 161         if (cn->cn_Node.mln_Succ)
 162         {
 163             cn->cn_Scan += size + sizeof(ULONG) + sizeof(ULONG);
 164         }
 165     }
 166
 167     return 0;
 168
 169     AROS_LIBFUNC_EXIT
 170 } /* PopChunk */