workbench/devs/AHI/Examples/Extras/CloneAudioModes/CloneAudioModes.c

   1
   2 #include <config.h>
   3
   4 #include <devices/ahi.h>
   5 #include <exec/memory.h>
   6 #include <libraries/ahi_sub.h>
   7 #include <libraries/iffparse.h>
   8 #include <proto/dos.h>
   9 #include <proto/exec.h>
  10 #include <proto/iffparse.h>
  11 #include <proto/utility.h>
  12
  13 #include <stdio.h>
  14 #include <ctype.h>
  15 #include <string.h>
  16
  17 #include "version.h"
  18
  19 static const char version[] = "$VER: CloneAudioModes " VERS "\n\r";
  20
  21 long __oslibversion = 39;
  22
  23 #define TEMPLATE "FROM/A,TO/A,BOARD/N,VERBOSE/S"
  24
  25 BOOL
  26 ProcessModeChunk( APTR* buffer, ULONG* size, ULONG* new_board );
  27
  28
  29 int
  30 main( void )
  31 {
  32   struct
  33   {
  34       STRPTR from;
  35       STRPTR to;
  36       ULONG* board;
  37       ULONG  verbose;
  38   } args = { NULL, NULL, NULL, FALSE };
  39
  40   struct RDArgs *rdargs;
  41   int            rc = RETURN_ERROR;
  42
  43   rdargs = ReadArgs( TEMPLATE , (LONG *) &args, NULL );
  44
  45   if( rdargs != NULL )
  46   {
  47     struct IFFHandle* from;
  48     struct IFFHandle* to;
  49     LONG              error;
  50
  51     from = AllocIFF();
  52     to   = AllocIFF();
  53
  54     if( from != NULL && to != NULL )
  55     {
  56       from->iff_Stream = (ULONG) Open( args.from, MODE_OLDFILE );
  57
  58       if( from->iff_Stream != 0 )
  59       {
  60         InitIFFasDOS( from );
  61
  62         error = OpenIFF( from, IFFF_READ );
  63
  64 /*      if( error == 0 ) */
  65 /*      { */
  66 /*        error = PropChunk( from, ID_AHIM, ID_AUDM ); */
  67 /*      } */
  68
  69 /*      if( error == 0 ) */
  70 /*      { */
  71 /*        error = PropChunk( from, ID_AHIM, ID_AUDN ); */
  72 /*      } */
  73
  74         if( error == 0 )
  75         {
  76           to->iff_Stream = (ULONG) Open( args.to, MODE_NEWFILE );
  77
  78           if( to->iff_Stream != 0 )
  79           {
  80             InitIFFasDOS( to );
  81
  82             error = OpenIFF( to, IFFF_WRITE );
  83
  84             if( error == 0 )
  85             {
  86               while( TRUE )
  87               {
  88                 struct ContextNode* cn = NULL;
  89
  90                 error = ParseIFF( from, IFFPARSE_STEP );
  91
  92                 if( error == 0 || error == IFFERR_EOC )
  93                 {
  94                   cn = CurrentChunk( from );
  95
  96                   if( cn == NULL )
  97                   {
  98                     PrintFault( ERROR_OBJECT_NOT_FOUND, "CurrentChunk()" );
  99                     break;
 100                   }
 101
 102                   if( cn->cn_Type != ID_AHIM )
 103                   {
 104                     Printf( "%s: Not an AHIM IFF file.\n", (ULONG) args.from );
 105                     break;
 106                   }
 107                 }
 108
 109
 110                 if( error == 0 )
 111                 {
 112                   char idbuf[ 5 ];
 113                   APTR  buffer;
 114                   ULONG size;
 115
 116                   error = 0;
 117
 118                   if( from->iff_Depth > 1 )
 119                   {
 120                     if( args.verbose )
 121                     {
 122                       IDtoStr( cn->cn_ID, idbuf );
 123
 124                       Printf( "Processing %s (%ld bytes) ... ",
 125                               (ULONG) idbuf, cn->cn_Size );
 126                     }
 127
 128                     size   = cn->cn_Size;
 129                     buffer = AllocVec( size, MEMF_ANY );
 130
 131                     if( buffer == NULL )
 132                     {
 133                       PrintFault( ERROR_NO_FREE_STORE, idbuf );
 134                       break;
 135                     }
 136
 137                     error = ReadChunkBytes( from, buffer, size );
 138
 139                     if( cn->cn_ID == ID_AUDM )
 140                     {
 141                       if( ! ProcessModeChunk( &buffer, &size, args.board ) )
 142                       {
 143                         PrintFault( ERROR_NO_FREE_STORE, idbuf );
 144                         break;
 145                       }
 146                     }
 147                   }
 148
 149                   if( error >= 0 )
 150                   {
 151                     error = PushChunk( to,
 152                                        cn->cn_Type, cn->cn_ID, IFFSIZE_UNKNOWN );
 153                   }
 154
 155                   if( from->iff_Depth > 1 )
 156                   {
 157                     if( error >= 0 )
 158                     {
 159                       error = WriteChunkBytes( to, buffer, size );
 160                     }
 161
 162                     FreeVec( buffer );
 163
 164                     if( error < 0 )
 165                     {
 166                       Printf( "%s: IFF error code %ld\n", (ULONG)
 167                               (ULONG) args.to, error );
 168                       break;
 169                     }
 170                   }
 171                 }
 172                 else if( error == IFFERR_EOC )
 173                 {
 174                   error = PopChunk( to );
 175
 176                   if( error != 0 )
 177                   {
 178                     Printf( "%s: IFF error code %ld\n", (ULONG) args.to, error );
 179                     break;
 180                   }
 181
 182                   if( from->iff_Depth > 1 && args.verbose )
 183                   {
 184                     Printf( "OK.\n" );
 185                   }
 186                 }
 187                 else if( error == IFFERR_EOF )
 188                 {
 189                   if( args.verbose )
 190                   {
 191                     Printf( "Done!\n" );
 192                   }
 193
 194                   rc = RETURN_OK;
 195                   break;
 196                 }
 197                 else
 198                 {
 199                   Printf( "%ld\n", error );
 200                   break;
 201                 }
 202               } // while
 203             }
 204             else
 205             {
 206               Printf( "%s: IFF error code %ld\n", (ULONG) args.to, error );
 207             }
 208
 209             Close( (BPTR) to->iff_Stream );
 210
 211             if( rc != RETURN_OK )
 212             {
 213               Printf( "Deleting destination file %s.\n", (ULONG) args.to );
 214               DeleteFile( args.to );
 215             }
 216           }
 217           else
 218           {
 219             PrintFault( IoErr(), args.to );
 220           }
 221         }
 222         else
 223         {
 224           Printf( "%s: IFF error code %ld\n", (ULONG) (ULONG) args.from, error );
 225         }
 226
 227         Close( (BPTR) from->iff_Stream );
 228       }
 229       else
 230       {
 231         PrintFault( IoErr(), args.from );
 232       }
 233     }
 234
 235     FreeIFF( from );
 236     FreeIFF( to );
 237
 238     FreeArgs( rdargs );
 239   }
 240   else
 241   {
 242     PrintFault( IoErr(), "CloneAudioModes" );
 243   }
 244
 245   return rc;
 246 }
 247
 248 BOOL
 249 ProcessModeChunk( APTR* buffer, ULONG* size, ULONG* new_board )
 250 {
 251   struct TagItem* tstate;
 252   struct TagItem* tag;
 253
 254   ULONG           board     = new_board == NULL ? 1 : *new_board - 1;
 255
 256   char*           name      = NULL;
 257   ULONG           name_size = 0;
 258   ULONG           tag_size  = 4;
 259
 260   APTR            new_buffer;
 261   ULONG*          ptr;
 262
 263   tstate = *buffer;
 264
 265   while( ( tag = NextTagItem( &tstate ) ) )
 266   {
 267     tag_size += sizeof( struct TagItem );
 268
 269     if( tag->ti_Tag == AHIDB_AudioID )
 270     {
 271       if( new_board == NULL )
 272       {
 273         board = ( ( tag->ti_Data >> 12 ) & 15 ) + 1;
 274       }
 275     }
 276     else if( tag->ti_Tag == AHIDB_Name )
 277     {
 278       name = tag->ti_Data + *buffer;
 279
 280       name_size = strlen( name ) + 1 + 2;
 281     }
 282   }
 283
 284   new_buffer = AllocVec( tag_size + name_size, MEMF_ANY );
 285
 286   if( new_buffer != NULL )
 287   {
 288     char* card;
 289     char* mode;
 290
 291     ptr = new_buffer;
 292
 293     tstate = *buffer;
 294
 295     while( ( tag = NextTagItem( &tstate ) ) )
 296     {
 297       *ptr++ = tag->ti_Tag;
 298
 299       if( tag->ti_Tag == AHIDB_AudioID )
 300       {
 301         *ptr++ = ( tag->ti_Data & 0xffff0fff ) | ( board << 12 );
 302       }
 303       else if( tag->ti_Tag == AHIDB_Name )
 304       {
 305         *ptr++ = tag_size;
 306       }
 307       else
 308       {
 309         *ptr++ = tag->ti_Data;
 310       }
 311     }
 312
 313     *ptr++ = TAG_DONE;
 314
 315     card = name;
 316
 317     while( *name != ':' && *name != 0 )
 318     {
 319       name++;
 320     }
 321
 322     if( name[ -2 ] == '-' && isdigit( name[ -1 ] ) )
 323     {
 324       name[ -2 ] = 0;
 325     }
 326
 327     *name++ = 0;
 328
 329     mode = name;
 330
 331     name_size = sprintf( (char*) ptr, "%s-%d:%s", card, (int) board + 1, mode );
 332     name_size += 1;
 333   }
 334
 335   FreeVec( *buffer );
 336
 337   *buffer = new_buffer;
 338   *size   = tag_size + name_size;
 339
 340   return new_buffer != NULL;
 341 }