Changeset 388

Show
Ignore:
Timestamp:
2004-02-06 06:55:09 (5 years ago)
Author:
conrad
Message:

added check for non-general metrics for seek_units

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • liboggz/trunk/include/oggz/oggz_constants.h

    r382 r388  
    6262   * once all bos pages have been delivered. */ 
    6363  OGGZ_AUTO         = 0x20 
     64}; 
     65 
     66enum OggzStatus { 
     67  OGGZ_STATUS_INITIALIZED = 0, 
     68  OGGZ_STATUS_INTERNAL_ERROR = 1, 
     69 
     70  OGGZ_STATUS_READ_ACTIVE = 10, 
     71  OGGZ_STATUS_READ_STOP_OK = 11, 
     72  OGGZ_STATUS_READ_STOP_ERR = 12, 
     73  OGGZ_STATUS_READ_EOF = 13 
    6474}; 
    6575 

  • liboggz/trunk/src/liboggz/oggz.c

    r383 r388  
    101101  } 
    102102 
     103  oggz->status = OGGZ_STATUS_INITIALIZED; 
     104 
    103105  return oggz; 
    104106} 
    …… 
    421423} 
    422424 
     425/* 
     426 * Check if an oggz has metrics for all streams 
     427 */ 
     428int 
     429oggz_has_metrics (OGGZ * oggz) 
     430{ 
     431  int i, size; 
     432  oggz_stream_t * stream; 
     433 
     434  if (oggz->metric != NULL) return 1; 
     435 
     436  size = oggz_vector_size (oggz->streams); 
     437  for (i = 0; i < size; i++) { 
     438    stream = (oggz_stream_t *)oggz_vector_nth_p (oggz->streams, i); 
     439    if (stream->metric == NULL) return 0; 
     440  } 
     441 
     442  return 1; 
     443} 
     444 
    423445ogg_int64_t 
    424446oggz_get_unit (OGGZ * oggz, long serialno, ogg_int64_t granulepos) 

  • liboggz/trunk/src/liboggz/oggz_byteorder.h

    r354 r388  
    3434#define __OGGZ_BYTEORDER_H__ 
    3535 
     36#ifdef _UNUSED_ 
    3637static  unsigned short 
    3738_le_16 (unsigned short s) 
    …… 
    4445  return ret; 
    4546} 
     47#endif 
    4648 
    4749static  ogg_uint32_t 

  • liboggz/trunk/src/liboggz/oggz_private.h

    r382 r388  
    167167struct _OGGZ { 
    168168  int flags; 
     169  enum OggzStatus status; 
     170 
    169171  FILE * file; 
    170172  OggzIO * io; 
    …… 
    206208int oggz_set_metric_internal (OGGZ * oggz, long serialno, OggzMetric metric, 
    207209                              void * user_data, int internal); 
     210int oggz_has_metrics (OGGZ * oggz); 
    208211 
    209212int oggz_purge (OGGZ * oggz); 

  • liboggz/trunk/src/liboggz/oggz_read.c

    r382 r388  
    204204{ 
    205205  OggzReader * reader = &oggz->x.reader; 
    206   long nread = 0; 
    207206 
    208207  oggz_stream_t * stream; 
    …… 
    216215  int cb_ret = 0; 
    217216 
     217  oggz->status = OGGZ_STATUS_READ_ACTIVE; 
     218 
    218219  /*os = &reader->ogg_stream;*/ 
    219220  op = &packet; 
    …… 
    221222  /* handle one packet.  Try to fetch it from current stream state */ 
    222223  /* extract packets from page */ 
    223   while(cb_ret == 0){ 
     224  while(cb_ret == OGGZ_CONTINUE) { 
    224225 
    225226    if (reader->current_serialno != -1) { 
    226     /* process a packet if we can.  If the machine isn't loaded, 
    227        neither is a page */ 
    228     while(cb_ret == 0) { 
    229       ogg_int64_t granulepos; 
    230       int result; 
    231  
    232       serialno = reader->current_serialno; 
     227      /* process a packet if we can.  If the machine isn't loaded, 
     228         neither is a page */ 
     229      while(cb_ret == OGGZ_CONTINUE) { 
     230        ogg_int64_t granulepos; 
     231        int result; 
     232 
     233        serialno = reader->current_serialno; 
     234 
     235        stream = oggz_get_stream (oggz, serialno); 
     236       
     237        if (stream == NULL) { 
     238          /* new stream ... check bos etc. */ 
     239          if ((stream = oggz_add_stream (oggz, serialno)) == NULL) { 
     240            /* error -- could not add stream */ 
     241            oggz->status = OGGZ_STATUS_INTERNAL_ERROR; 
     242            return -7; 
     243          } 
     244        } 
     245        os = &stream->ogg_stream; 
     246 
     247        result = ogg_stream_packetout(os, op); 
     248 
     249        if(result == -1) { 
     250          /* hole in the data. */ 
     251          oggz->status = OGGZ_STATUS_INTERNAL_ERROR; 
     252          return -7; 
     253        } 
     254 
     255        if(result > 0){ 
     256          /* got a packet.  process it */ 
     257          granulepos = op->granulepos; 
     258 
     259          if (!stream->metric && (oggz->flags & OGGZ_AUTO)) { 
     260            oggz_auto (oggz, op, serialno, NULL); 
     261          } 
     262 
     263          if ((oggz->metric || stream->metric) && granulepos != -1) { 
     264            reader->current_unit = oggz_get_unit (oggz, serialno, granulepos); 
     265          } 
     266#ifndef DEBUG_BY_READING_PAGES 
     267          if (stream->read_packet) { 
     268            cb_ret = 
     269              stream->read_packet (oggz, op, serialno, stream->read_user_data); 
     270          } else if (reader->read_packet) { 
     271            cb_ret = 
     272              reader->read_packet (oggz, op, serialno, reader->read_user_data); 
     273          } 
     274#endif /* DEBUG_BY_READING_PAGES */ 
     275        } 
     276        else 
     277          break; 
     278      } 
     279    } 
     280 
     281    if (cb_ret == OGGZ_CONTINUE) { 
     282      if(oggz_get_next_page_7 (oggz, &og) < 0) { 
     283        if (reader->current_unit != 0) 
     284          oggz->status = OGGZ_STATUS_READ_EOF; 
     285        return -404; /* eof. leave unitialized */ 
     286      } 
     287 
     288      serialno = ogg_page_serialno (&og); 
     289      reader->current_serialno = serialno; /* XXX: maybe not necessary */ 
    233290 
    234291      stream = oggz_get_stream (oggz, serialno); 
    …… 
    238295        if ((stream = oggz_add_stream (oggz, serialno)) == NULL) { 
    239296          /* error -- could not add stream */ 
     297          oggz->status = OGGZ_STATUS_INTERNAL_ERROR; 
    240298          return -7; 
    241299        } 
    …… 
    243301      os = &stream->ogg_stream; 
    244302 
    245       result = ogg_stream_packetout(os, op); 
    246  
    247       if(result == -1) { 
    248         /* hole in the data. */ 
    249         return -7; 
    250       } 
    251  
    252       if(result > 0){ 
    253         /* got a packet.  process it */ 
    254         granulepos = op->granulepos; 
    255  
    256         if (!stream->metric && (oggz->flags & OGGZ_AUTO)) { 
    257           oggz_auto (oggz, op, serialno, NULL); 
     303#ifdef DEBUG_BY_READING_PAGES 
     304      { 
     305        ogg_packet op_debug; 
     306        op_debug.packet = og.body; 
     307        op_debug.bytes = og.body_len; 
     308        op_debug.b_o_s = ogg_page_bos (&og); 
     309        op_debug.e_o_s = ogg_page_eos (&og); 
     310        op_debug.granulepos = ogg_page_granulepos (&og); 
     311        op_debug.packetno = ogg_page_packets (&og); 
     312 
     313        if (stream->read_packet) { 
     314          cb_ret = stream->read_packet (oggz, &op_debug, serialno, 
     315                                        stream->read_user_data); 
     316        } else if (reader->read_packet) { 
     317          cb_ret = reader->read_packet (oggz, &op_debug, serialno, 
     318                                        reader->read_user_data); 
    258319        } 
    259  
    260         if ((oggz->metric || stream->metric) && granulepos != -1) { 
    261           reader->current_unit = oggz_get_unit (oggz, serialno, granulepos); 
    262         } 
    263 #ifndef DEBUG_BY_READING_PAGES 
    264         if (stream->read_packet) { 
    265           cb_ret = 
    266             stream->read_packet (oggz, op, serialno, stream->read_user_data); 
    267         } else if (reader->read_packet) { 
    268           cb_ret = 
    269             reader->read_packet (oggz, op, serialno, reader->read_user_data); 
    270         } 
    271 #endif /* DEBUG_BY_READING_PAGES */ 
    272       } 
    273       else 
    274         break; 
    275     } 
    276     } 
    277  
    278     /* If we've got a stop already, don't read more data in */ 
    279     if (cb_ret != 0) return cb_ret; 
    280  
    281     if(oggz_get_next_page_7 (oggz, &og) < 0) 
    282       return -404; /* eof. leave unitialized */ 
    283  
    284     serialno = ogg_page_serialno (&og); 
    285     reader->current_serialno = serialno; /* XXX: maybe not necessary */ 
    286  
    287     stream = oggz_get_stream (oggz, serialno); 
    288        
    289     if (stream == NULL) { 
    290       /* new stream ... check bos etc. */ 
    291       if ((stream = oggz_add_stream (oggz, serialno)) == NULL) { 
    292         /* error -- could not add stream */ 
    293         return -7; 
    294       } 
    295     } 
    296     os = &stream->ogg_stream; 
    297  
    298 #ifdef DEBUG_BY_READING_PAGES 
    299     { 
    300       ogg_packet op_debug; 
    301       op_debug.packet = og.body; 
    302       op_debug.bytes = og.body_len; 
    303       op_debug.b_o_s = ogg_page_bos (&og); 
    304       op_debug.e_o_s = ogg_page_eos (&og); 
    305       op_debug.granulepos = ogg_page_granulepos (&og); 
    306       op_debug.packetno = ogg_page_packets (&og); 
    307  
    308       if (stream->read_packet) { 
    309         cb_ret = stream->read_packet (oggz, &op_debug, serialno, 
    310                                       stream->read_user_data); 
    311       } else if (reader->read_packet) { 
    312         cb_ret = reader->read_packet (oggz, &op_debug, serialno, 
    313                                       reader->read_user_data); 
    314       } 
    315     } 
     320      } 
    316321#endif 
    317322 
    318323#if 0 
    319     /* bitrate tracking; add the header's bytes here, the body bytes 
    320        are done by packet above */ 
    321     vf->bittrack+=og.header_len*8; 
    322 #endif 
    323  
    324     ogg_stream_pagein(os, &og); 
     324      /* bitrate tracking; add the header's bytes here, the body bytes 
     325         are done by packet above */ 
     326      vf->bittrack+=og.header_len*8; 
     327#endif 
     328 
     329      ogg_stream_pagein(os, &og); 
     330    } 
     331 
     332    if (cb_ret == OGGZ_CONTINUE) { 
     333      oggz->status = OGGZ_STATUS_READ_ACTIVE; 
     334    } else if (cb_ret == OGGZ_STOP_ERR) { 
     335      oggz->status = OGGZ_STATUS_READ_STOP_ERR; 
     336    } else { 
     337      oggz->status = OGGZ_STATUS_READ_STOP_OK; 
     338    } 
    325339  } 
    326340 
    …… 
    346360  cb_ret = oggz_read_sync (oggz); 
    347361 
    348   /* If there's nothing to read yet, don't flag an error */ 
    349   if (reader->current_unit == 0 && cb_ret == -404) cb_ret = 0; 
    350  
    351   while (cb_ret != -1 && cb_ret != 1 && bytes_read > 0 && remaining > 0) { 
     362  while (oggz->status == OGGZ_STATUS_READ_ACTIVE && 
     363         bytes_read > 0 && remaining > 0) { 
    352364    bytes = MIN (remaining, 4096); 
    353365    buffer = ogg_sync_buffer (&reader->ogg_sync, bytes); 
    354366    if ((bytes_read = (long) oggz_io_read (oggz, buffer, bytes)) == 0) { 
    355  
    356       if (ferror (oggz->file)) { 
    357         return OGGZ_ERR_SYSTEM; 
    358       } 
     367      /* schyeah! */ 
     368    } 
     369    if (bytes_read == OGGZ_ERR_SYSTEM) { 
     370      return OGGZ_ERR_SYSTEM; 
    359371    } 
    360372 
    …… 
    367379  } 
    368380 
    369   if (cb_ret == -1) oggz_purge (oggz); 
     381  if (oggz->status == OGGZ_STATUS_READ_STOP_ERR) 
     382    oggz_purge (oggz); 
    370383 
    371384  return nread; 
    …… 
    379392  char * buffer; 
    380393  long bytes, remaining = n, nread = 0; 
    381   int cb_ret = 0; 
    382394 
    383395  if (oggz == NULL) return OGGZ_ERR_BAD_OGGZ; 
    …… 
    389401  reader = &oggz->x.reader; 
    390402 
    391   cb_ret = oggz_read_sync (oggz); 
    392  
    393   /* If there's nothing to read yet, don't flag an error */ 
    394   if (reader->current_unit == 0 && cb_ret == -404) cb_ret = 0; 
    395  
    396   while (cb_ret != -1 && cb_ret != 1 && /* !oggz->eos && */ remaining > 0) { 
     403  oggz_read_sync (oggz); 
     404 
     405  while (oggz->status == OGGZ_STATUS_READ_ACTIVE && /* !oggz->eos && */ 
     406         remaining > 0) { 
    397407    bytes = MIN (remaining, 4096); 
    398408    buffer = ogg_sync_buffer (&reader->ogg_sync, bytes); 
    …… 
    404414    nread += bytes; 
    405415 
    406     cb_ret = oggz_read_sync (oggz);     
    407   } 
    408  
    409   if (cb_ret == -1) oggz_purge (oggz); 
     416    oggz_read_sync (oggz);     
     417  } 
     418 
     419  if (oggz->status == OGGZ_STATUS_READ_STOP_ERR) 
     420    oggz_purge (oggz); 
    410421 
    411422  return nread; 
    …… 
    512523oggz_purge (OGGZ * oggz) 
    513524{ 
    514   long reset_ret; 
    515  
    516525  if (oggz == NULL) return OGGZ_ERR_BAD_OGGZ; 
    517526 
    …… 
    10721081  } 
    10731082 
    1074   if (oggz->metric == NULL) { 
     1083  if (!oggz_has_metrics (oggz)) { 
    10751084    return -1; 
    10761085  } 

  • liboggz/trunk/src/liboggz/oggz_write.c

    r382 r388  
    5959/* #define ALWAYS_FLUSH */ 
    6060 
     61/* #define ZPACKET_CMP */ 
     62 
     63#ifdef ZPACKET_CMP 
    6164static int 
    6265oggz_zpacket_cmp (oggz_writer_packet_t * a, oggz_writer_packet_t * b, 
    …… 
    7679  else return (unit_a > unit_b); 
    7780} 
     81#endif 
    7882 
    7983OGGZ * 
    …… 
    8690  writer->packet_queue = oggz_vector_new (); 
    8791 
    88 #if 0 
     92#ifdef ZPACKET_CMP 
    8993  /* XXX: comparison function should only kick in when a metric is set */ 
    9094  oggz_vector_set_cmp (writer->packet_queue,