src/apps/cortex/Persistence/Wrappers/MediaFormatIO.cpp

   1 /*
   2  * Copyright (c) 1999-2000, Eric Moon.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions, and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions, and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * 3. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  23  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  26  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  27  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31
  32 // MediaFormatIO.cpp
  33 // e.moon 2jul99
  34
  35 #include "MediaFormatIO.h"
  36 //#include "xml_export_utils.h"
  37
  38 __USE_CORTEX_NAMESPACE
  39
  40 // -------------------------------------------------------- //
  41 // *** constants
  42 // -------------------------------------------------------- //
  43
  44 // these tags map directly to MediaFormatIO
  45 const char* const MediaFormatIO::s_multi_audio_tag                      = "multi_audio_format";
  46 const char* const MediaFormatIO::s_raw_audio_tag                                = "raw_audio_format";
  47 const char* const MediaFormatIO::s_raw_video_tag                                = "raw_video_format";
  48 const char* const MediaFormatIO::s_multistream_tag                      = "multistream_format";
  49 const char* const MediaFormatIO::s_encoded_audio_tag            = "encoded_audio_format";
  50 const char* const MediaFormatIO::s_encoded_video_tag            = "encoded_video_format";
  51
  52 // nested tags
  53 const char* const MediaFormatIO::s_video_display_info_tag               = "video_display_info";
  54 const char* const MediaFormatIO::s_multistream_flags_tag                        = "multistream_flags";
  55 const char* const MediaFormatIO::s_multistream_vid_info_tag     = "multistream_vid_info";
  56 const char* const MediaFormatIO::s_multistream_avi_info_tag     = "multistream_avi_info";
  57 const char* const MediaFormatIO::s_multi_audio_info_tag                 = "multi_audio_info";
  58 const char* const MediaFormatIO::s_media_type_tag                                               = "media_type";
  59
  60 // -------------------------------------------------------- //
  61 // *** ctor/dtor
  62 // -------------------------------------------------------- //
  63
  64 MediaFormatIO::~MediaFormatIO() {}
  65
  66 MediaFormatIO::MediaFormatIO() :
  67         m_complete(false) {}
  68 MediaFormatIO::MediaFormatIO(const media_format& format) :
  69         m_complete(true),
  70         m_format(format) {}
  71
  72 // -------------------------------------------------------- //
  73 // *** accessors
  74 // -------------------------------------------------------- //
  75
  76 // returns B_OK if the object contains a valid format,
  77 // or B_ERROR if not.
  78
  79 status_t MediaFormatIO::getFormat(media_format& outFormat) const {
  80         if(!m_complete)
  81                 return B_ERROR;
  82         outFormat = m_format;
  83         return B_OK;
  84 }
  85
  86 // -------------------------------------------------------- //
  87 // *** static setup method
  88 // -------------------------------------------------------- //
  89
  90 // call this method to install hooks for the tags needed by
  91 // MediaFormatIO
  92
  93 /*static*/
  94 void MediaFormatIO::AddTo(XML::DocumentType* pDocType) {
  95
  96         pDocType->addMapping(new Mapping
  97                 <MediaFormatIO>(s_multi_audio_tag));
  98         pDocType->addMapping(new Mapping
  99                 <MediaFormatIO>(s_raw_audio_tag));
 100         pDocType->addMapping(new Mapping
 101                 <MediaFormatIO>(s_raw_video_tag));
 102         pDocType->addMapping(new Mapping
 103                 <MediaFormatIO>(s_multistream_tag));
 104         pDocType->addMapping(new Mapping
 105                 <MediaFormatIO>(s_encoded_audio_tag));
 106         pDocType->addMapping(new Mapping
 107                 <MediaFormatIO>(s_encoded_video_tag));
 108 }
 109
 110 // -------------------------------------------------------- //
 111 // *** IPersistent
 112 // -------------------------------------------------------- //
 113
 114 // -------------------------------------------------------- //
 115 // attribute constants
 116 // -------------------------------------------------------- //
 117
 118 // *** raw_audio_format
 119 const char* const gKey_frame_rate                                                       = "frame_rate";
 120 const char* const gKey_channel_count                                    = "channel_count";
 121 const char* const gKey_format                                                                   = "format";
 122 const char* const gKey_byte_order                                                       = "byte_order";
 123 const char* const gKey_buffer_size                                              = "buffer_size";
 124
 125 // *** +multi_audio_format
 126 const char* const gKey_channel_mask                                             = "channel_mask";
 127 const char* const gKey_valid_bits                                                       = "valid_bits";
 128 const char* const gKey_matrix_mask                                              = "matrix_mask";
 129
 130 // *** raw_video_format
 131 const char* const gKey_field_rate                                                       = "field_rate";
 132 const char* const gKey_interlace                                                        = "interlace";
 133 const char* const gKey_first_active                                             = "first_active";
 134 const char* const gKey_last_active                                              = "last_active";
 135 const char* const gKey_orientation                                              = "orientation";
 136 const char* const gKey_pixel_width_aspect                       = "pixel_width_aspect";
 137 const char* const gKey_pixel_height_aspect              = "pixel_height_aspect";
 138
 139 // *** video_display_info
 140 const char* const gKey_color_space                                              = "color_space";
 141 const char* const gKey_line_width                                                       = "line_width";
 142 const char* const gKey_line_count                                                       = "line_count";
 143 const char* const gKey_bytes_per_row                                    = "bytes_per_row";
 144 const char* const gKey_pixel_offset                                             = "pixel_offset";
 145 const char* const gKey_line_offset                                              = "line_offset";
 146
 147 // *** multistream_format
 148 const char* const gKey_multistream_format                       = "format";
 149 const char* const gKey_avg_bit_rate                                             = "avg_bit_rate";
 150 const char* const gKey_max_bit_rate                                             = "max_bit_rate";
 151 const char* const gKey_avg_chunk_size                                   = "avg_chunk_size";
 152 const char* const gKey_max_chunk_size                                   = "max_chunk_size";
 153
 154 // *** multistream_flags
 155 const char* const gKey_header_has_flags                         = "header_has_flags";
 156 const char* const gKey_clean_buffers                                    = "clean_buffers";
 157 const char* const gKey_homogenous_buffers                       = "homogenous_buffers";
 158
 159 // *** multistream_vid_info
 160 // frame_rate
 161 const char* const gKey_width                                                                    = "width";
 162 const char* const gKey_height                                                                   = "height";
 163 const char* const gKey_space                                                                    = "space";
 164 const char* const gKey_sampling_rate                                    = "sampling_rate";
 165 const char* const gKey_sample_format                                    = "sample_format";
 166 // byte_order
 167 // channel_count
 168
 169 // *** multistream_avi_info
 170 const char* const gKey_us_per_frame                                             = "us_per_frame";
 171 // width
 172 // height
 173
 174 // *** encoded_audio_format
 175 const char* const gKey_encoding                                                         = "encoding";
 176 const char* const gKey_bit_rate                                                         = "bit_rate";
 177 const char* const gKey_frame_size                                                       = "frame_size";
 178
 179 // *** encoded_video_format
 180 // encoding
 181 // avg_bit_rate
 182 // max_bit_rate
 183 // frame_size
 184 const char* const gKey_forward_history                          = "forward_history";
 185 const char* const gKey_backward_history                         = "backward_history";
 186
 187 // padding (number of spaces allowed for attribute name)
 188 const int16 g_padAttributes             = 30;
 189
 190 // -------------------------------------------------------- //
 191 // export
 192 // -------------------------------------------------------- //
 193
 194 void write_colorspace_attr(
 195         const char* key,
 196         color_space c,
 197         ExportContext& context) {
 198
 199         switch(c) {
 200                 case B_RGB32:
 201                         context.writeAttr(key, "B_RGB32");
 202                         break;
 203                 case B_RGBA32:
 204                         context.writeAttr(key, "B_RGBA32");
 205                         break;
 206                 case B_RGB24:
 207                         context.writeAttr(key, "B_RGB24");
 208                         break;
 209                 case B_RGB16:
 210                         context.writeAttr(key, "B_RGB16");
 211                         break;
 212                 case B_RGB15:
 213                         context.writeAttr(key, "B_RGB15");
 214                         break;
 215                 case B_RGBA15:
 216                         context.writeAttr(key, "B_RGBA15");
 217                         break;
 218                 case B_CMAP8:
 219                         context.writeAttr(key, "B_CMAP8");
 220                         break;
 221                 case B_GRAY8:
 222                         context.writeAttr(key, "B_GRAY8");
 223                         break;
 224                 case B_GRAY1:
 225                         context.writeAttr(key, "B_GRAY1");
 226                         break;
 227                 case B_RGB32_BIG:
 228                         context.writeAttr(key, "B_RGB32_BIG");
 229                         break;
 230                 case B_RGBA32_BIG:
 231                         context.writeAttr(key, "B_RGBA32_BIG");
 232                         break;
 233                 case B_RGB24_BIG:
 234                         context.writeAttr(key, "B_RGB24_BIG");
 235                         break;
 236                 case B_RGB16_BIG:
 237                         context.writeAttr(key, "B_RGB16_BIG");
 238                         break;
 239                 case B_RGB15_BIG:
 240                         context.writeAttr(key, "B_RGB15_BIG");
 241                         break;
 242                 case B_RGBA15_BIG:
 243                         context.writeAttr(key, "B_RGBA15_BIG");
 244                         break;
 245                 case B_YCbCr422:
 246                         context.writeAttr(key, "B_YCbCr422");
 247                         break;
 248                 case B_YCbCr411:
 249                         context.writeAttr(key, "B_YCbCr411");
 250                         break;
 251                 case B_YCbCr444:
 252                         context.writeAttr(key, "B_YCbCr444");
 253                         break;
 254                 case B_YCbCr420:
 255                         context.writeAttr(key, "B_YCbCr420");
 256                         break;
 257                 case B_YUV422:
 258                         context.writeAttr(key, "B_YUV422");
 259                         break;
 260                 case B_YUV411:
 261                         context.writeAttr(key, "B_YUV411");
 262                         break;
 263                 case B_YUV444:
 264                         context.writeAttr(key, "B_YUV444");
 265                         break;
 266                 case B_YUV420:
 267                         context.writeAttr(key, "B_YUV420");
 268                         break;
 269                 case B_YUV9:
 270                         context.writeAttr(key, "B_YUV9");
 271                         break;
 272                 case B_YUV12:
 273                         context.writeAttr(key, "B_YUV12");
 274                         break;
 275                 case B_UVL24:
 276                         context.writeAttr(key, "B_UVL24");
 277                         break;
 278                 case B_UVL32:
 279                         context.writeAttr(key, "B_UVL32");
 280                         break;
 281                 case B_UVLA32:
 282                         context.writeAttr(key, "B_UVLA32");
 283                         break;
 284                 case B_LAB24:
 285                         context.writeAttr(key, "B_LAB24");
 286                         break;
 287                 case B_LAB32:
 288                         context.writeAttr(key, "B_LAB32");
 289                         break;
 290                 case B_LABA32:
 291                         context.writeAttr(key, "B_LABA32");
 292                         break;
 293                 case B_HSI24:
 294                         context.writeAttr(key, "B_HSI24");
 295                         break;
 296                 case B_HSI32:
 297                         context.writeAttr(key, "B_HSI32");
 298                         break;
 299                 case B_HSIA32:
 300                         context.writeAttr(key, "B_HSIA32");
 301                         break;
 302                 case B_HSV24:
 303                         context.writeAttr(key, "B_HSV24");
 304                         break;
 305                 case B_HSV32:
 306                         context.writeAttr(key, "B_HSV32");
 307                         break;
 308                 case B_HSVA32:
 309                         context.writeAttr(key, "B_HSVA32");
 310                         break;
 311                 case B_HLS24:
 312                         context.writeAttr(key, "B_HLS24");
 313                         break;
 314                 case B_HLS32:
 315                         context.writeAttr(key, "B_HLS32");
 316                         break;
 317                 case B_HLSA32:
 318                         context.writeAttr(key, "B_HLSA32");
 319                         break;
 320                 case B_CMY24:
 321                         context.writeAttr(key, "B_CMY24");
 322                         break;
 323                 case B_CMY32:
 324                         context.writeAttr(key, "B_CMY32");
 325                         break;
 326                 case B_CMYA32:
 327                         context.writeAttr(key, "B_CMYA32");
 328                         break;
 329                 case B_CMYK32:
 330                         context.writeAttr(key, "B_CMYK32");
 331                         break;
 332                 default:
 333                         break;
 334         }
 335 }
 336
 337 void import_color_space(
 338         const char* value,
 339         color_space& dest) {
 340
 341         if(!strcmp(value, "B_RGB32"))
 342                 dest = B_RGB32;
 343         else if(!strcmp(value, "B_RGBA32"))
 344                 dest = B_RGBA32;
 345         else if(!strcmp(value, "B_RGB24"))
 346                 dest = B_RGB24;
 347         else if(!strcmp(value, "B_RGB16"))
 348                 dest = B_RGB16;
 349         else if(!strcmp(value, "B_RGB15"))
 350                 dest = B_RGB15;
 351         else if(!strcmp(value, "B_RGBA15"))
 352                 dest = B_RGBA15;
 353         else if(!strcmp(value, "B_CMAP8"))
 354                 dest = B_CMAP8;
 355         else if(!strcmp(value, "B_GRAY8"))
 356                 dest = B_GRAY8;
 357         else if(!strcmp(value, "B_GRAY1"))
 358                 dest = B_GRAY1;
 359         else if(!strcmp(value, "B_RGB32_BIG"))
 360                 dest = B_RGB32_BIG;
 361         else if(!strcmp(value, "B_RGBA32_BIG"))
 362                 dest = B_RGBA32_BIG;
 363         else if(!strcmp(value, "B_RGB24_BIG"))
 364                 dest = B_RGB24_BIG;
 365         else if(!strcmp(value, "B_RGB16_BIG"))
 366                 dest = B_RGB16_BIG;
 367         else if(!strcmp(value, "B_RGB15_BIG"))
 368                 dest = B_RGB15_BIG;
 369         else if(!strcmp(value, "B_RGBA15_BIG"))
 370                 dest = B_RGBA15_BIG;
 371         else if(!strcmp(value, "B_RGB32_LITTLE"))
 372                 dest = B_RGB32_LITTLE;
 373         else if(!strcmp(value, "B_RGBA32_LITTLE"))
 374                 dest = B_RGBA32_LITTLE;
 375         else if(!strcmp(value, "B_RGB24_LITTLE"))
 376                 dest = B_RGB24_LITTLE;
 377         else if(!strcmp(value, "B_RGB16_LITTLE"))
 378                 dest = B_RGB16_LITTLE;
 379         else if(!strcmp(value, "B_RGB15_LITTLE"))
 380                 dest = B_RGB15_LITTLE;
 381         else if(!strcmp(value, "B_RGBA15_LITTLE"))
 382                 dest = B_RGBA15_LITTLE;
 383         else if(!strcmp(value, "B_YCbCr422"))
 384                 dest = B_YCbCr422;
 385         else if(!strcmp(value, "B_YCbCr411"))
 386                 dest = B_YCbCr411;
 387         else if(!strcmp(value, "B_YCbCr444"))
 388                 dest = B_YCbCr444;
 389         else if(!strcmp(value, "B_YCbCr420"))
 390                 dest = B_YCbCr420;
 391         else if(!strcmp(value, "B_YUV422"))
 392                 dest = B_YUV422;
 393         else if(!strcmp(value, "B_YUV411"))
 394                 dest = B_YUV411;
 395         else if(!strcmp(value, "B_YUV444"))
 396                 dest = B_YUV444;
 397         else if(!strcmp(value, "B_YUV420"))
 398                 dest = B_YUV420;
 399         else if(!strcmp(value, "B_YUV9"))
 400                 dest = B_YUV9;
 401         else if(!strcmp(value, "B_YUV12"))
 402                 dest = B_YUV12;
 403         else if(!strcmp(value, "B_UVL24"))
 404                 dest = B_UVL24;
 405         else if(!strcmp(value, "B_UVL32"))
 406                 dest = B_UVL32;
 407         else if(!strcmp(value, "B_UVLA32"))
 408                 dest = B_UVLA32;
 409         else if(!strcmp(value, "B_LAB24"))
 410                 dest = B_LAB24;
 411         else if(!strcmp(value, "B_LAB32"))
 412                 dest = B_LAB32;
 413         else if(!strcmp(value, "B_LABA32"))
 414                 dest = B_LABA32;
 415         else if(!strcmp(value, "B_HSI24"))
 416                 dest = B_HSI24;
 417         else if(!strcmp(value, "B_HSI32"))
 418                 dest = B_HSI32;
 419         else if(!strcmp(value, "B_HSIA32"))
 420                 dest = B_HSIA32;
 421         else if(!strcmp(value, "B_HSV24"))
 422                 dest = B_HSV24;
 423         else if(!strcmp(value, "B_HSV32"))
 424                 dest = B_HSV32;
 425         else if(!strcmp(value, "B_HSVA32"))
 426                 dest = B_HSVA32;
 427         else if(!strcmp(value, "B_HLS24"))
 428                 dest = B_HLS24;
 429         else if(!strcmp(value, "B_HLS32"))
 430                 dest = B_HLS32;
 431         else if(!strcmp(value, "B_HLSA32"))
 432                 dest = B_HLSA32;
 433         else if(!strcmp(value, "B_CMY24"))
 434                 dest = B_CMY24;
 435         else if(!strcmp(value, "B_CMY32"))
 436                 dest = B_CMY32;
 437         else if(!strcmp(value, "B_CMYA32"))
 438                 dest = B_CMYA32;
 439         else if(!strcmp(value, "B_CMYK32"))
 440                 dest = B_CMYK32;
 441 }
 442
 443 void write_media_type(
 444         media_type t,
 445         ExportContext& context) {
 446
 447         context.beginElement(MediaFormatIO::s_media_type_tag);
 448         context.beginContent();
 449
 450         switch(t) {
 451                 case B_MEDIA_NO_TYPE:
 452                         context.writeString("B_MEDIA_NO_TYPE");
 453                         break;
 454                 case B_MEDIA_UNKNOWN_TYPE:
 455                         context.writeString("B_MEDIA_UNKNOWN_TYPE");
 456                         break;
 457                 case B_MEDIA_RAW_AUDIO:
 458                         context.writeString("B_MEDIA_RAW_AUDIO");
 459                         break;
 460                 case B_MEDIA_RAW_VIDEO:
 461                         context.writeString("B_MEDIA_RAW_VIDEO");
 462                         break;
 463                 case B_MEDIA_VBL:
 464                         context.writeString("B_MEDIA_VBL");
 465                         break;
 466                 case B_MEDIA_TIMECODE:
 467                         context.writeString("B_MEDIA_TIMECODE");
 468                         break;
 469                 case B_MEDIA_MIDI:
 470                         context.writeString("B_MEDIA_MIDI");
 471                         break;
 472                 case B_MEDIA_TEXT:
 473                         context.writeString("B_MEDIA_TEXT");
 474                         break;
 475                 case B_MEDIA_HTML:
 476                         context.writeString("B_MEDIA_HTML");
 477                         break;
 478                 case B_MEDIA_MULTISTREAM:
 479                         context.writeString("B_MEDIA_MULTISTREAM");
 480                         break;
 481                 case B_MEDIA_PARAMETERS:
 482                         context.writeString("B_MEDIA_PARAMETERS");
 483                         break;
 484                 case B_MEDIA_ENCODED_AUDIO:
 485                         context.writeString("B_MEDIA_ENCODED_AUDIO");
 486                         break;
 487                 case B_MEDIA_ENCODED_VIDEO:
 488                         context.writeString("B_MEDIA_ENCODED_VIDEO");
 489                         break;
 490                 default: {
 491                         BString val;
 492                         val << (uint32)t;
 493                         context.writeString(val);
 494                 }
 495         }
 496         context.endElement();
 497 }
 498
 499 void import_media_type_content(
 500         media_multistream_format::avi_info& f,
 501         const char* value,
 502         ImportContext& context) {
 503
 504         if(f.type_count == 5) {
 505                 // ignore
 506                 // +++++ should this be an error?
 507                 context.reportWarning("Ignoring media_type: maximum of 5 reached.");
 508                 return;
 509         }
 510
 511         if(!strcmp(value, "B_MEDIA_NO_TYPE"))
 512                 f.types[f.type_count] = B_MEDIA_NO_TYPE;
 513         else if(!strcmp(value, "B_MEDIA_UNKNOWN_TYPE"))
 514                 f.types[f.type_count] = B_MEDIA_UNKNOWN_TYPE;
 515         else if(!strcmp(value, "B_MEDIA_RAW_AUDIO"))
 516                 f.types[f.type_count] = B_MEDIA_RAW_AUDIO;
 517         else if(!strcmp(value, "B_MEDIA_RAW_VIDEO"))
 518                 f.types[f.type_count] = B_MEDIA_RAW_VIDEO;
 519         else if(!strcmp(value, "B_MEDIA_VBL"))
 520                 f.types[f.type_count] = B_MEDIA_VBL;
 521         else if(!strcmp(value, "B_MEDIA_TIMECODE"))
 522                 f.types[f.type_count] = B_MEDIA_TIMECODE;
 523         else if(!strcmp(value, "B_MEDIA_MIDI"))
 524                 f.types[f.type_count] = B_MEDIA_MIDI;
 525         else if(!strcmp(value, "B_MEDIA_TEXT"))
 526                 f.types[f.type_count] = B_MEDIA_TEXT;
 527         else if(!strcmp(value, "B_MEDIA_HTML"))
 528                 f.types[f.type_count] = B_MEDIA_HTML;
 529         else if(!strcmp(value, "B_MEDIA_MULTISTREAM"))
 530                 f.types[f.type_count] = B_MEDIA_MULTISTREAM;
 531         else if(!strcmp(value, "B_MEDIA_PARAMETERS"))
 532                 f.types[f.type_count] = B_MEDIA_PARAMETERS;
 533         else if(!strcmp(value, "B_MEDIA_ENCODED_AUDIO"))
 534                 f.types[f.type_count] = B_MEDIA_ENCODED_AUDIO;
 535         else if(!strcmp(value, "B_MEDIA_ENCODED_VIDEO"))
 536                 f.types[f.type_count] = B_MEDIA_ENCODED_VIDEO;
 537         else
 538                 f.types[f.type_count] = (media_type)atol(value);
 539
 540         ++f.type_count;
 541 }
 542
 543
 544 void export_raw_audio_attr(
 545         const media_raw_audio_format& f,
 546         ExportContext& context) {
 547
 548         media_raw_audio_format& w = media_raw_audio_format::wildcard;
 549
 550         if(f.frame_rate != w.frame_rate)
 551                 context.writeAttr(gKey_frame_rate, f.frame_rate);
 552         if(f.channel_count != w.channel_count)
 553                 context.writeAttr(gKey_channel_count, f.channel_count);
 554         if(f.buffer_size != w.buffer_size)
 555                 context.writeAttr(gKey_buffer_size, f.buffer_size);
 556
 557         switch(f.format) {
 558                 case media_raw_audio_format::B_AUDIO_UCHAR:
 559                         context.writeAttr(gKey_format, "B_AUDIO_UCHAR");
 560                         break;
 561                 case media_raw_audio_format::B_AUDIO_SHORT:
 562                         context.writeAttr(gKey_format, "B_AUDIO_SHORT");
 563                         break;
 564                 case media_raw_audio_format::B_AUDIO_FLOAT:
 565                         context.writeAttr(gKey_format, "B_AUDIO_FLOAT");
 566                         break;
 567                 case media_raw_audio_format::B_AUDIO_INT:
 568                         context.writeAttr(gKey_format, "B_AUDIO_INT");
 569                         break;
 570                 default:
 571                         break;
 572         }
 573
 574         switch(f.byte_order) {
 575                 case B_MEDIA_BIG_ENDIAN:
 576                         context.writeAttr(gKey_byte_order, "B_MEDIA_BIG_ENDIAN");
 577                         break;
 578                 case B_MEDIA_LITTLE_ENDIAN:
 579                         context.writeAttr(gKey_byte_order, "B_MEDIA_LITTLE_ENDIAN");
 580                         break;
 581                 default:
 582                         break;
 583         }
 584 }
 585
 586 void export_multi_audio_info_attr(
 587         const media_multi_audio_info& f,
 588         ExportContext& context) {
 589
 590         media_multi_audio_format& w = media_multi_audio_format::wildcard;
 591
 592         if(f.channel_mask != w.channel_mask)
 593                 context.writeAttr(gKey_channel_mask, f.channel_mask);
 594
 595         if(f.valid_bits != w.valid_bits)
 596                 context.writeAttr(gKey_valid_bits, f.valid_bits);
 597
 598         if(f.matrix_mask != w.matrix_mask)
 599                 context.writeAttr(gKey_matrix_mask, f.matrix_mask);
 600 }
 601
 602 void export_video_display_info_attr(
 603         const media_video_display_info& d,
 604         ExportContext& context) {
 605
 606         media_video_display_info& w = media_video_display_info::wildcard;
 607
 608         if(d.line_width != w.line_width)
 609                 context.writeAttr(gKey_line_width, d.line_width);
 610         if(d.line_count != w.line_count)
 611                 context.writeAttr(gKey_line_count, d.line_count);
 612         if(d.bytes_per_row != w.bytes_per_row)
 613                 context.writeAttr(gKey_bytes_per_row, d.bytes_per_row);
 614         if(d.pixel_offset != w.pixel_offset)
 615                 context.writeAttr(gKey_pixel_offset, d.pixel_offset);
 616         if(d.line_offset != w.line_offset)
 617                 context.writeAttr(gKey_line_offset, d.line_offset);
 618
 619         if(d.format != w.format)
 620                 write_colorspace_attr(gKey_format, d.format, context);
 621 }
 622
 623
 624 void export_raw_video_attr(
 625         const media_raw_video_format& f,
 626         ExportContext& context) {
 627
 628         media_raw_video_format& w = media_raw_video_format::wildcard;
 629
 630         // attributes
 631         if(f.field_rate != w.field_rate)
 632                 context.writeAttr(gKey_field_rate, f.field_rate);
 633         if(f.interlace != w.interlace)
 634                 context.writeAttr(gKey_interlace, f.interlace);
 635         if(f.first_active != w.first_active)
 636                 context.writeAttr(gKey_first_active, f.first_active);
 637         if(f.last_active != w.last_active)
 638                 context.writeAttr(gKey_last_active, f.last_active);
 639         if(f.pixel_width_aspect != w.pixel_width_aspect)
 640                 context.writeAttr(gKey_pixel_width_aspect, (uint32)f.pixel_width_aspect);
 641         if(f.pixel_height_aspect != w.pixel_height_aspect)
 642                 context.writeAttr(gKey_pixel_height_aspect, (uint32)f.pixel_height_aspect);
 643
 644         switch(f.orientation) {
 645                 case B_VIDEO_TOP_LEFT_RIGHT:
 646                         context.writeAttr(gKey_orientation, "B_VIDEO_TOP_LEFT_RIGHT");
 647                         break;
 648                 case B_VIDEO_BOTTOM_LEFT_RIGHT:
 649                         context.writeAttr(gKey_orientation, "B_VIDEO_BOTTOM_LEFT_RIGHT");
 650                         break;
 651                 default:
 652                         break;
 653         }
 654 }
 655
 656 void export_raw_video_content(
 657         const media_raw_video_format& f,
 658         ExportContext& context) {
 659
 660         context.beginContent();
 661         context.beginElement(MediaFormatIO::s_video_display_info_tag);
 662         export_video_display_info_attr(f.display, context);
 663         context.endElement();
 664 }
 665
 666 void export_multistream_flags_attr(
 667         uint32 flags,
 668         ExportContext& context) {
 669
 670         if(flags & media_multistream_format::B_HEADER_HAS_FLAGS)
 671                 context.writeAttr(gKey_header_has_flags, (int32)1);
 672
 673         if(flags & media_multistream_format::B_CLEAN_BUFFERS)
 674                 context.writeAttr(gKey_clean_buffers, (int32)1);
 675
 676         if(flags & media_multistream_format::B_HOMOGENOUS_BUFFERS)
 677                 context.writeAttr(gKey_homogenous_buffers, (int32)1);
 678 }
 679
 680 void export_multistream_vid_info_attr(
 681         media_multistream_format::vid_info f,
 682         ExportContext& context) {
 683
 684         // +++++ no wildcard to compare against (assume 0 == wildcard?)
 685
 686         context.writeAttr(gKey_frame_rate, f.frame_rate);
 687         context.writeAttr(gKey_width, (uint32)f.width);
 688         context.writeAttr(gKey_height, (uint32)f.height);
 689         write_colorspace_attr(gKey_space, f.space, context);
 690         context.writeAttr(gKey_sampling_rate, f.sampling_rate);
 691
 692         switch(f.sample_format) {
 693                 case B_UNDEFINED_SAMPLES:
 694                         context.writeAttr(gKey_sample_format, "B_UNDEFINED_SAMPLES");
 695                         break;
 696                 case B_LINEAR_SAMPLES:
 697                         context.writeAttr(gKey_sample_format, "B_LINEAR_SAMPLES");
 698                         break;
 699                 case B_FLOAT_SAMPLES:
 700                         context.writeAttr(gKey_sample_format, "B_FLOAT_SAMPLES");
 701                         break;
 702                 case B_MULAW_SAMPLES:
 703                         context.writeAttr(gKey_sample_format, "B_MULAW_SAMPLES");
 704                         break;
 705                 default:
 706                         break;
 707         }
 708
 709         switch(f.byte_order) {
 710                 case B_MEDIA_BIG_ENDIAN:
 711                         context.writeAttr(gKey_byte_order, "B_MEDIA_BIG_ENDIAN");
 712                         break;
 713                 case B_MEDIA_LITTLE_ENDIAN:
 714                         context.writeAttr(gKey_byte_order, "B_MEDIA_LITTLE_ENDIAN");
 715                         break;
 716                 default:
 717                         break;
 718         }
 719
 720         context.writeAttr(gKey_channel_count, (uint32)f.channel_count);
 721 }
 722
 723 void export_multistream_avi_info_attr(
 724         media_multistream_format::avi_info f,
 725         ExportContext& context) {
 726
 727         context.writeAttr(gKey_us_per_frame, f.us_per_frame);
 728         context.writeAttr(gKey_width, (uint32)f.width);
 729         context.writeAttr(gKey_height, (uint32)f.height);
 730 }
 731
 732 void export_multistream_avi_info_content(
 733         media_multistream_format::avi_info f,
 734         ExportContext& context) {
 735
 736         context.beginContent();
 737
 738         for(uint16 n = 0; n < f.type_count; ++n)
 739                 write_media_type(f.types[n], context);
 740 }
 741
 742 void export_multistream_attr(
 743         const media_multistream_format& f,
 744         ExportContext& context) {
 745
 746         media_multistream_format& w = media_multistream_format::wildcard;
 747
 748         // attributes
 749         switch(f.format) {
 750                 case media_multistream_format::B_ANY:
 751                         context.writeAttr(gKey_multistream_format, "B_ANY");
 752                         break;
 753                 case media_multistream_format::B_VID:
 754                         context.writeAttr(gKey_multistream_format, "B_VID");
 755                         break;
 756                 case media_multistream_format::B_AVI:
 757                         context.writeAttr(gKey_multistream_format, "B_AVI");
 758                         break;
 759                 case media_multistream_format::B_MPEG1:
 760                         context.writeAttr(gKey_multistream_format, "B_MPEG1");
 761                         break;
 762                 case media_multistream_format::B_MPEG2:
 763                         context.writeAttr(gKey_multistream_format, "B_MPEG2");
 764                         break;
 765                 case media_multistream_format::B_QUICKTIME:
 766                         context.writeAttr(gKey_multistream_format, "B_QUICKTIME");
 767                         break;
 768                 default:
 769                         if(f.format != w.format) {
 770                                 // write numeric value
 771                                 context.writeAttr(gKey_multistream_format, f.format);
 772                         }
 773                         break;
 774         }
 775
 776         if(f.avg_bit_rate != w.avg_bit_rate)
 777                 context.writeAttr(gKey_avg_bit_rate, f.avg_bit_rate);
 778         if(f.max_bit_rate != w.max_bit_rate)
 779                 context.writeAttr(gKey_max_bit_rate, f.max_bit_rate);
 780         if(f.avg_chunk_size != w.avg_chunk_size)
 781                 context.writeAttr(gKey_avg_chunk_size, f.avg_chunk_size);
 782         if(f.max_chunk_size != w.max_chunk_size)
 783                 context.writeAttr(gKey_max_chunk_size, f.max_chunk_size);
 784 }
 785
 786 void export_multistream_content(
 787         const media_multistream_format& f,
 788         ExportContext& context) {
 789
 790         context.beginContent();
 791
 792         // write flags
 793         context.beginElement(MediaFormatIO::s_multistream_flags_tag);
 794         export_multistream_flags_attr(f.flags, context);
 795         context.endElement();
 796
 797         // write format-specific info
 798         if(f.format == media_multistream_format::B_VID) {
 799                 context.beginElement(MediaFormatIO::s_multistream_vid_info_tag);
 800                 export_multistream_vid_info_attr(f.u.vid, context);
 801                 context.endElement();
 802         }
 803         else if(f.format == media_multistream_format::B_AVI) {
 804                 context.beginElement(MediaFormatIO::s_multistream_avi_info_tag);
 805                 export_multistream_avi_info_attr(f.u.avi, context);
 806                 context.beginContent();
 807                 export_multistream_avi_info_content(f.u.avi, context);
 808                 context.endElement();
 809         }
 810 }
 811
 812 void export_encoded_audio_attr(
 813         const media_encoded_audio_format& f,
 814         ExportContext& context) {
 815
 816         media_encoded_audio_format& w = media_encoded_audio_format::wildcard;
 817
 818         switch(f.encoding) {
 819                 case media_encoded_audio_format::B_ANY:
 820                         context.writeAttr(gKey_encoding, "B_ANY");
 821                         break;
 822                 default:
 823                         break;
 824         }
 825
 826         if(f.bit_rate != w.bit_rate)
 827                 context.writeAttr(gKey_bit_rate, f.bit_rate);
 828
 829         if(f.frame_size != w.frame_size)
 830                 context.writeAttr(gKey_frame_size, f.frame_size);
 831 }
 832
 833 void export_encoded_audio_content(
 834         const media_encoded_audio_format& f,
 835         ExportContext& context) {
 836
 837         context.beginContent();
 838
 839         context.beginElement(MediaFormatIO::s_raw_audio_tag);
 840         export_raw_audio_attr(f.output, context);
 841
 842         export_multi_audio_info_attr(f.multi_info, context);
 843
 844         context.endElement();
 845 }
 846
 847 void export_encoded_video_attr(
 848         const media_encoded_video_format& f,
 849         ExportContext& context) {
 850
 851         media_encoded_video_format& w = media_encoded_video_format::wildcard;
 852
 853         switch(f.encoding) {
 854                 case media_encoded_video_format::B_ANY:
 855                         context.writeAttr(gKey_encoding, "B_ANY");
 856                         break;
 857                 default:
 858                         break;
 859         }
 860
 861         if(f.avg_bit_rate != w.avg_bit_rate)
 862                 context.writeAttr(gKey_avg_bit_rate, f.avg_bit_rate);
 863         if(f.max_bit_rate != w.max_bit_rate)
 864                 context.writeAttr(gKey_max_bit_rate, f.max_bit_rate);
 865         if(f.frame_size != w.frame_size)
 866                 context.writeAttr(gKey_frame_size, f.frame_size);
 867         if(f.forward_history != w.forward_history)
 868                 context.writeAttr(gKey_forward_history, (int32)f.forward_history);
 869         if(f.backward_history != w.backward_history)
 870                 context.writeAttr(gKey_backward_history, (int32)f.backward_history);
 871 }
 872
 873 void export_encoded_video_content(
 874         const media_encoded_video_format& f,
 875         ExportContext& context) {
 876
 877         context.beginContent();
 878
 879         context.beginElement(MediaFormatIO::s_raw_video_tag);
 880         export_raw_video_attr(f.output, context);
 881         context.endElement();
 882 }
 883
 884
 885 void MediaFormatIO::xmlExportBegin(
 886         ExportContext&          context) const {
 887
 888         switch(m_format.type) {
 889
 890                 case B_MEDIA_RAW_AUDIO:
 891                         context.beginElement(s_raw_audio_tag);
 892                         break;
 893
 894                 case B_MEDIA_RAW_VIDEO:
 895                         context.beginElement(s_raw_video_tag);
 896                         break;
 897
 898                 case B_MEDIA_MULTISTREAM:
 899                         context.beginElement(s_multistream_tag);
 900                         break;
 901
 902                 case B_MEDIA_ENCODED_AUDIO:
 903                         context.beginElement(s_encoded_audio_tag);
 904                         break;
 905
 906                 case B_MEDIA_ENCODED_VIDEO:
 907                         context.beginElement(s_encoded_video_tag);
 908                         break;
 909
 910                 default:
 911                         // +++++ not very polite
 912                         context.reportError("MediaFormatIO: type not supported\n");
 913                         break;
 914         }
 915 }
 916
 917 void MediaFormatIO::xmlExportAttributes(
 918         ExportContext&          context) const {
 919
 920         switch(m_format.type) {
 921                 case B_MEDIA_RAW_AUDIO:
 922                         export_raw_audio_attr(m_format.u.raw_audio, context);
 923                         export_multi_audio_info_attr(m_format.u.raw_audio, context);
 924                         break;
 925
 926                 case B_MEDIA_RAW_VIDEO:
 927                         export_raw_video_attr(m_format.u.raw_video, context);
 928                         break;
 929
 930                 case B_MEDIA_MULTISTREAM:
 931                         export_multistream_attr(m_format.u.multistream, context);
 932                         break;
 933
 934                 case B_MEDIA_ENCODED_AUDIO:
 935                         export_encoded_audio_attr(m_format.u.encoded_audio, context);
 936                         break;
 937
 938                 case B_MEDIA_ENCODED_VIDEO:
 939                         export_encoded_video_attr(m_format.u.encoded_video, context);
 940                         break;
 941
 942                 default:
 943                         break;
 944         }
 945 }
 946
 947 void MediaFormatIO::xmlExportContent(
 948         ExportContext&          context) const {
 949
 950         switch(m_format.type) {
 951                 case B_MEDIA_RAW_VIDEO:
 952                         export_raw_video_content(m_format.u.raw_video, context);
 953                         break;
 954
 955                 case B_MEDIA_MULTISTREAM:
 956                         export_multistream_content(m_format.u.multistream, context);
 957                         break;
 958
 959                 case B_MEDIA_ENCODED_AUDIO:
 960                         export_encoded_audio_content(m_format.u.encoded_audio, context);
 961                         break;
 962
 963                 case B_MEDIA_ENCODED_VIDEO:
 964                         export_encoded_video_content(m_format.u.encoded_video, context);
 965                         break;
 966
 967                 default:
 968                         break;
 969         }
 970 }
 971
 972 void MediaFormatIO::xmlExportEnd(
 973         ExportContext&          context) const {
 974
 975         context.endElement();
 976 }
 977
 978 // -------------------------------------------------------- //
 979 // import
 980 // -------------------------------------------------------- //
 981
 982 void import_raw_audio_attribute(
 983         media_raw_audio_format& f,
 984         const char* key,
 985         const char* value,
 986         ImportContext& context) {
 987
 988         if(!strcmp(key, gKey_frame_rate))
 989                 f.frame_rate = atof(value);
 990         else if(!strcmp(key, gKey_channel_count))
 991                 f.channel_count = atol(value);
 992         else if(!strcmp(key, gKey_buffer_size))
 993                 f.buffer_size = atol(value);
 994         else if(!strcmp(key, gKey_format)) {
 995                 if(!strcmp(value, "B_AUDIO_UCHAR"))
 996                         f.format = media_raw_audio_format::B_AUDIO_UCHAR;
 997                 else if(!strcmp(value, "B_AUDIO_SHORT"))
 998                         f.format = media_raw_audio_format::B_AUDIO_SHORT;
 999                 else if(!strcmp(value, "B_AUDIO_FLOAT"))
1000                         f.format = media_raw_audio_format::B_AUDIO_FLOAT;
1001                 else if(!strcmp(value, "B_AUDIO_INT"))
1002                         f.format = media_raw_audio_format::B_AUDIO_INT;
1003         }
1004         else if(!strcmp(key, gKey_byte_order)) {
1005                 if(!strcmp(value, "B_MEDIA_BIG_ENDIAN"))
1006                         f.byte_order = B_MEDIA_BIG_ENDIAN;
1007                 else if(!strcmp(value, "B_MEDIA_LITTLE_ENDIAN"))
1008                         f.byte_order = B_MEDIA_LITTLE_ENDIAN;
1009         }
1010 }
1011
1012 void import_multi_audio_info_attribute(
1013         media_multi_audio_info& f,
1014         const char* key,
1015         const char* value,
1016         ImportContext& context) {
1017
1018         if(!strcmp(key, gKey_channel_mask))
1019                 f.channel_mask = atol(value);
1020         else if(!strcmp(key, gKey_valid_bits))
1021                 f.valid_bits = atoi(value);
1022         else if(!strcmp(key, gKey_matrix_mask))
1023                 f.matrix_mask = atoi(value);
1024 }
1025
1026 void import_raw_video_attribute(
1027         media_raw_video_format& f,
1028         const char* key,
1029         const char* value,
1030         ImportContext& context) {
1031
1032         if(!strcmp(key, gKey_field_rate))
1033                 f.field_rate = atof(value);
1034         else if(!strcmp(key, gKey_interlace))
1035                 f.interlace = atol(value);
1036         else if(!strcmp(key, gKey_first_active))
1037                 f.first_active = atol(value);
1038         else if(!strcmp(key, gKey_last_active))
1039                 f.last_active = atol(value);
1040         else if(!strcmp(key, gKey_pixel_width_aspect))
1041                 f.pixel_width_aspect = atol(value);
1042         else if(!strcmp(key, gKey_pixel_height_aspect))
1043                 f.pixel_height_aspect = atol(value);
1044         else if(!strcmp(key, gKey_orientation)) {
1045                 if(!strcmp(value, "B_VIDEO_TOP_LEFT_RIGHT"))
1046                         f.orientation = B_VIDEO_TOP_LEFT_RIGHT;
1047                 else if(!strcmp(value, "B_VIDEO_BOTTOM_LEFT_RIGHT"))
1048                         f.orientation = B_VIDEO_BOTTOM_LEFT_RIGHT;
1049         }
1050 }
1051
1052 void import_video_display_info_attribute(
1053         media_video_display_info& d,
1054         const char* key,
1055         const char* value,
1056         ImportContext& context) {
1057
1058         if(!strcmp(key, gKey_line_width))
1059                 d.line_width = atol(value);
1060         else if(!strcmp(key, gKey_line_count))
1061                 d.line_count = atol(value);
1062         else if(!strcmp(key, gKey_bytes_per_row))
1063                 d.bytes_per_row = atol(value);
1064         else if(!strcmp(key, gKey_pixel_offset))
1065                 d.pixel_offset = atol(value);
1066         else if(!strcmp(key, gKey_line_offset))
1067                 d.line_offset = atol(value);
1068         else if(!strcmp(key, gKey_format)) {
1069                 import_color_space(value, d.format);
1070         }
1071 }
1072
1073 void import_multistream_attribute(
1074         media_multistream_format& f,
1075         const char* key,
1076         const char* value,
1077         ImportContext& context) {
1078
1079         if(!strcmp(key, gKey_format)) {
1080                 if(!strcmp(value, "B_ANY"))
1081                         f.format = media_multistream_format::B_ANY;
1082                 else if(!strcmp(value, "B_VID"))
1083                         f.format = media_multistream_format::B_VID;
1084                 else if(!strcmp(value, "B_AVI"))
1085                         f.format = media_multistream_format::B_AVI;
1086                 else if(!strcmp(value, "B_MPEG1"))
1087                         f.format = media_multistream_format::B_MPEG1;
1088                 else if(!strcmp(value, "B_MPEG2"))
1089                         f.format = media_multistream_format::B_MPEG2;
1090                 else if(!strcmp(value, "B_QUICKTIME"))
1091                         f.format = media_multistream_format::B_QUICKTIME;
1092                 else
1093                         f.format = atol(value);
1094         }
1095         else if(!strcmp(key, gKey_avg_bit_rate))
1096                 f.avg_bit_rate = atof(value);
1097         else if(!strcmp(key, gKey_max_bit_rate))
1098                 f.max_bit_rate = atof(value);
1099         else if(!strcmp(key, gKey_avg_chunk_size))
1100                 f.avg_chunk_size = atol(value);
1101         else if(!strcmp(key, gKey_max_chunk_size))
1102                 f.max_chunk_size = atol(value);
1103 }
1104
1105 void import_multistream_flags_attribute(
1106         uint32& flags,
1107         const char* key,
1108         const char* value,
1109         ImportContext& context) {
1110
1111         if(!atol(value))
1112                 return;
1113
1114         if(!strcmp(key, gKey_header_has_flags))
1115                 flags |= media_multistream_format::B_HEADER_HAS_FLAGS;
1116         else if(!strcmp(key, gKey_clean_buffers))
1117                 flags |= media_multistream_format::B_CLEAN_BUFFERS;
1118         else if(!strcmp(key, gKey_homogenous_buffers))
1119                 flags |= media_multistream_format::B_HOMOGENOUS_BUFFERS;
1120 }
1121
1122 void import_multistream_vid_info_attribute(
1123         media_multistream_format::vid_info& f,
1124         const char* key,
1125         const char* value,
1126         ImportContext& context) {
1127
1128         if(!strcmp(key, gKey_frame_rate))
1129                 f.frame_rate = atof(value);
1130         else if(!strcmp(key, gKey_width))
1131                 f.width = atol(value);
1132         else if(!strcmp(key, gKey_height))
1133                 f.height = atol(value);
1134         else if(!strcmp(key, gKey_space))
1135                 import_color_space(value, f.space);
1136         else if(!strcmp(key, gKey_sampling_rate))
1137                 f.sampling_rate = atof(value);
1138         else if(!strcmp(key, gKey_channel_count))
1139                 f.channel_count = atol(value);
1140         else if(!strcmp(key, gKey_sample_format)) {
1141                 if(!strcmp(value, "B_UNDEFINED_SAMPLES"))
1142                         f.sample_format = B_UNDEFINED_SAMPLES;
1143                 else if(!strcmp(value, "B_LINEAR_SAMPLES"))
1144                         f.sample_format = B_LINEAR_SAMPLES;
1145                 else if(!strcmp(value, "B_FLOAT_SAMPLES"))
1146                         f.sample_format = B_FLOAT_SAMPLES;
1147                 else if(!strcmp(value, "B_MULAW_SAMPLES"))
1148                         f.sample_format = B_MULAW_SAMPLES;
1149         }
1150         else if(!strcmp(key, gKey_byte_order)) {
1151                 if(!strcmp(value, "B_MEDIA_BIG_ENDIAN"))
1152                         f.byte_order = B_MEDIA_BIG_ENDIAN;
1153                 else if(!strcmp(value, "B_MEDIA_LITTLE_ENDIAN"))
1154                         f.byte_order = B_MEDIA_LITTLE_ENDIAN;
1155         }
1156 }
1157
1158 void import_multistream_avi_info_attribute(
1159         media_multistream_format::avi_info& f,
1160         const char* key,
1161         const char* value,
1162         ImportContext& context) {
1163
1164         if(!strcmp(key, gKey_us_per_frame))
1165                 f.us_per_frame = atol(value);
1166         else if(!strcmp(key, gKey_width))
1167                 f.width = atol(value);
1168         else if(!strcmp(key, gKey_height))
1169                 f.height = atol(value);
1170 }
1171
1172 void import_encoded_audio_attribute(
1173         media_encoded_audio_format& f,
1174         const char* key,
1175         const char* value,
1176         ImportContext& context) {
1177
1178         if(!strcmp(key, gKey_encoding)) {
1179                 if(!strcmp(value, "B_ANY"))
1180                         f.encoding = media_encoded_audio_format::B_ANY;
1181         }
1182         else if(!strcmp(key, gKey_bit_rate))
1183                 f.bit_rate = atof(value);
1184         else if(!strcmp(key, gKey_frame_size))
1185                 f.frame_size = atol(value);
1186 }
1187
1188 void import_encoded_video_attribute(
1189         media_encoded_video_format& f,
1190         const char* key,
1191         const char* value,
1192         ImportContext& context) {
1193
1194         if(!strcmp(key, gKey_encoding)) {
1195                 if(!strcmp(value, "B_ANY"))
1196                         f.encoding = media_encoded_video_format::B_ANY;
1197         }
1198         else if(!strcmp(key, gKey_avg_bit_rate))
1199                 f.avg_bit_rate = atof(value);
1200         else if(!strcmp(key, gKey_max_bit_rate))
1201                 f.max_bit_rate = atof(value);
1202         else if(!strcmp(key, gKey_frame_size))
1203                 f.frame_size = atol(value);
1204         else if(!strcmp(key, gKey_forward_history))
1205                 f.forward_history = atol(value);
1206         else if(!strcmp(key, gKey_backward_history))
1207                 f.backward_history = atol(value);
1208 }
1209
1210 // -------------------------------------------------------- //
1211
1212 void MediaFormatIO::xmlImportBegin(
1213         ImportContext&          context) {
1214
1215         // initialize format
1216         if(!strcmp(context.element(), s_raw_audio_tag)) {
1217                 m_format.type = B_MEDIA_RAW_AUDIO;
1218                 m_format.u.raw_audio = media_raw_audio_format::wildcard;
1219         }
1220         else if(!strcmp(context.element(), s_raw_video_tag)) {
1221                 m_format.type = B_MEDIA_RAW_VIDEO;
1222                 m_format.u.raw_video = media_raw_video_format::wildcard;
1223         }
1224         else if(!strcmp(context.element(), s_multistream_tag)) {
1225                 m_format.type = B_MEDIA_MULTISTREAM;
1226                 m_format.u.multistream = media_multistream_format::wildcard;
1227         }
1228         else if(!strcmp(context.element(), s_encoded_audio_tag)) {
1229                 m_format.type = B_MEDIA_ENCODED_AUDIO;
1230                 m_format.u.encoded_audio = media_encoded_audio_format::wildcard;
1231         }
1232         else if(!strcmp(context.element(), s_encoded_video_tag)) {
1233                 m_format.type = B_MEDIA_ENCODED_VIDEO;
1234                 m_format.u.encoded_video = media_encoded_video_format::wildcard;
1235         }
1236         else
1237                 context.reportError("Bad element mapping?  MediaFormatIO can't cope.");
1238 }
1239
1240 void MediaFormatIO::xmlImportAttribute(
1241         const char*                                     key,
1242         const char*                                     value,
1243         ImportContext&          context) {
1244         switch(m_format.type) {
1245                 case B_MEDIA_RAW_AUDIO:
1246                         import_raw_audio_attribute(
1247                                 m_format.u.raw_audio, key, value, context);
1248
1249                         import_multi_audio_info_attribute(
1250                                 m_format.u.raw_audio, key, value, context);
1251                         break;
1252
1253                 case B_MEDIA_RAW_VIDEO:
1254                         import_raw_video_attribute(
1255                                 m_format.u.raw_video, key, value, context);
1256                         break;
1257
1258                 case B_MEDIA_MULTISTREAM:
1259                         import_multistream_attribute(
1260                                 m_format.u.multistream, key, value, context);
1261                         break;
1262
1263                 case B_MEDIA_ENCODED_AUDIO:
1264                         import_encoded_audio_attribute(
1265                                 m_format.u.encoded_audio, key, value, context);
1266                         break;
1267
1268                 case B_MEDIA_ENCODED_VIDEO:
1269                         import_encoded_video_attribute(
1270                                 m_format.u.encoded_video, key, value, context);
1271                         break;
1272
1273                 default:
1274                         context.reportError("MediaFormatIO: bad type.");
1275         }
1276 }
1277
1278 void MediaFormatIO::xmlImportContent(
1279         const char*                                     data,
1280         uint32                                          length,
1281         ImportContext&          context) {}
1282
1283 void MediaFormatIO::xmlImportChild(
1284         IPersistent*                    child,
1285         ImportContext&          context) {
1286
1287         MediaFormatIO* childAsFormat = dynamic_cast<MediaFormatIO*>(child);
1288         if(m_format.type == B_MEDIA_ENCODED_AUDIO) {
1289                 if (childAsFormat == NULL
1290                         || childAsFormat->m_format.type != B_MEDIA_RAW_AUDIO) {
1291                         context.reportError("Expected a raw_audio_format.");
1292                 } else {
1293                         m_format.u.encoded_audio.output =
1294                                 childAsFormat->m_format.u.raw_audio;
1295                 }
1296         }
1297         else if(m_format.type == B_MEDIA_ENCODED_VIDEO) {
1298                 if (childAsFormat == NULL
1299                         || childAsFormat->m_format.type != B_MEDIA_RAW_VIDEO) {
1300                         context.reportError("Expected a raw_video_format.");
1301                 } else {
1302                         m_format.u.encoded_video.output =
1303                                 childAsFormat->m_format.u.raw_video;
1304                 }
1305         }
1306         else {
1307                 // +++++ should this be an error?
1308                 context.reportWarning("MediaFormatIO: Unexpected child element.");
1309         }
1310         delete child;
1311 }
1312
1313 void MediaFormatIO::xmlImportComplete(
1314         ImportContext&          context) {
1315
1316         // +++++ validity checks?
1317
1318         m_complete = true;
1319 }
1320
1321 void MediaFormatIO::xmlImportChildBegin(
1322         const char*                                     name,
1323         ImportContext&          context) {
1324
1325         if(!strcmp(name, s_video_display_info_tag)) {
1326                 if(m_format.type != B_MEDIA_RAW_VIDEO)
1327                         context.reportError("MediaFormatIO: unexpected element.");
1328         }
1329         else if(!strcmp(name, s_multistream_flags_tag)) {
1330                 if(m_format.type != B_MEDIA_MULTISTREAM)
1331                         context.reportError("MediaFormatIO: unexpected element.");
1332         }
1333         else if(!strcmp(name, s_multistream_vid_info_tag)) {
1334                 if(m_format.type != B_MEDIA_MULTISTREAM ||
1335                         m_format.u.multistream.format != media_multistream_format::B_VID)
1336                         context.reportError("MediaFormatIO: unexpected element.");
1337         }
1338         else if(!strcmp(name, s_multistream_avi_info_tag)) {
1339                 if(m_format.type != B_MEDIA_MULTISTREAM ||
1340                         m_format.u.multistream.format != media_multistream_format::B_AVI)
1341                         context.reportError("MediaFormatIO: unexpected element.");
1342         }
1343         else if(!strcmp(name, s_media_type_tag)) {
1344                 if(m_format.type != B_MEDIA_MULTISTREAM ||
1345                         m_format.u.multistream.format != media_multistream_format::B_AVI)
1346                         context.reportError("MediaFormatIO: unexpected element.");
1347         }
1348 }
1349
1350 void MediaFormatIO::xmlImportChildAttribute(
1351         const char*                                     key,
1352         const char*                                     value,
1353         ImportContext&          context) {
1354
1355         if(!strcmp(context.element(), s_video_display_info_tag))
1356                 import_video_display_info_attribute(
1357                         m_format.u.raw_video.display, key, value, context);
1358
1359         else if(!strcmp(context.element(), s_multistream_flags_tag      ))
1360                 import_multistream_flags_attribute(
1361                         m_format.u.multistream.flags, key, value, context);
1362
1363         else if(!strcmp(context.element(), s_multistream_vid_info_tag   ))
1364                 import_multistream_vid_info_attribute(
1365                         m_format.u.multistream.u.vid, key, value, context);
1366
1367         else if(!strcmp(context.element(), s_multistream_avi_info_tag   ))
1368                 import_multistream_avi_info_attribute(
1369                         m_format.u.multistream.u.avi, key, value, context);
1370
1371         else
1372                 context.reportError("MediaFormatIO: bad child element.");
1373 }
1374
1375 void MediaFormatIO::xmlImportChildContent(
1376         const char*                                     data,
1377         uint32                                          length,
1378         ImportContext&          context) {
1379
1380         if(!strcmp(context.element(), s_media_type_tag)) {
1381                 m_mediaType.Append(data, length);
1382         }
1383 }
1384
1385 void MediaFormatIO::xmlImportChildComplete(
1386         const char*                                     name,
1387         ImportContext&          context) {
1388
1389         if(!strcmp(context.element(), s_media_type_tag)) {
1390                 import_media_type_content(
1391                         m_format.u.multistream.u.avi,
1392                         m_mediaType.String(),   context);
1393
1394                 m_mediaType = "";
1395         }
1396 }
1397
1398
1399 // END -- MediaFormatIO.cpp --