cinelerra-5.1/libzmpeg3/libzmpeg3.C

   1 #include <errno.h>
   2 #include <fcntl.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <limits.h>
   6
   7 #include "libzmpeg3.h"
   8
   9 static uint8_t def_palette[] = { /* better than nothing */
  10   0x00, 0x80, 0x80, 0x00, /* black  #000000 */
  11   0xff, 0x80, 0x80, 0x00, /* white  #ffffff */
  12   0x4c, 0x54, 0xff, 0x00, /* red    #ff0000 */
  13   0x96, 0x2b, 0x15, 0x00, /* green  #00ff00 */
  14   0x1d, 0xff, 0x6b, 0x00, /* blue   #0000ff */
  15   0xe2, 0x00, 0x94, 0x00, /* yellow #ffff00 */
  16   0x69, 0xd4, 0xea, 0x00, /* purple #ff00ff */
  17   0xb3, 0xab, 0x00, 0x00, /* cyan   #00ffff */
  18   0x80, 0x80, 0x80, 0x00, /* grey   #808080 */
  19   0xa6, 0x6a, 0xbf, 0x00, /* pink   #ff8080 */
  20   0xcb, 0x55, 0x4a, 0x00, /* lime   #80ff80 */
  21   0x8e, 0xbf, 0x75, 0x00, /* lavndr #8080ff */
  22   0xd9, 0x95, 0x40, 0x00, /* brt cyan   #80ffff */
  23   0xb4, 0xaa, 0xb5, 0x00, /* brt purple #ff80ff */
  24   0xf1, 0x40, 0x8a, 0x00, /* brt yellow #ffff80 */
  25   0xff, 0x80, 0x80, 0x00, /* white  #ffffff */
  26 };
  27
  28 int zmpeg3_t::
  29 init(const char *title_path)
  30 {
  31   cpus = 1;
  32   vts_title = 0;
  33   total_vts_titles = 1;
  34   interleave = angle = 0;
  35   total_interleaves = 1;
  36   bitfont_t::init_fonts();
  37   demuxer = new demuxer_t(this, 0, 0, -1);
  38   seekable = 1;  log_errs = getenv("LOG_ERRS") ? 1 : 0;
  39   memcpy(&palette[0], &def_palette[0], sizeof(def_palette));
  40   char *cp = getenv("PTS_PADDING");
  41   pts_padding = cp ? atoi(cp) : 1;
  42   index_bytes = 0x300000;
  43   cell_time = -1.;
  44   recd_fd = -1;
  45   iopened = fs->is_open;
  46   int ret = !iopened ? fs->open_file() : 0;
  47   if( ret == 0 ) {
  48     int toc_atracks = INT_MAX;
  49     int toc_vtracks = INT_MAX;
  50     ret = get_file_type(&toc_atracks, &toc_vtracks, title_path);
  51     if( ret == 0 ) {
  52       /* Start from scratch */
  53       if( !demuxer->total_titles )
  54         demuxer->create_title();
  55       /* Generate tracks */
  56       if( is_transport_stream() || is_program_stream() ) {
  57         int i, n;
  58         /* Create video tracks */
  59         for( i=n=0; i<MAX_STREAMZ && total_vtracks<toc_vtracks; ++i ) {
  60           if( demuxer->vstream_table[i] ) {
  61             vtrack[total_vtracks] = new_vtrack_t(i, demuxer, n++);
  62             if( vtrack[total_vtracks] ) ++total_vtracks;
  63           }
  64         }
  65         /* Create audio tracks */
  66         for( i=n=0; i<MAX_STREAMZ && total_atracks<toc_atracks; ++i ) {
  67           int format = demuxer->astream_table[i];
  68           if( format > 0 ) {
  69             atrack[total_atracks] = new_atrack_t(i, format, demuxer, n++);
  70             if( atrack[total_atracks] ) ++total_atracks;
  71           }
  72         }
  73         /* Create subtile tracks */
  74         for( i=0; i<MAX_STREAMZ; ++i ) {
  75           if( demuxer->sstream_table[i] ) {
  76             strack[total_stracks] = new strack_t(i);
  77             if( strack[total_stracks] ) ++total_stracks;
  78           }
  79         }
  80       }
  81       else if( is_video_stream() ) {
  82         /* Create video tracks */
  83         vtrack[0] = new_vtrack_t(-1, demuxer, 0);
  84         if( vtrack[0] ) ++total_vtracks;
  85       }
  86       else if( is_audio_stream() ) {
  87         /* Create audio tracks */
  88         atrack[0] = new_atrack_t(-1, afmt_UNKNOWN, demuxer, 0);
  89         if( atrack[0] ) ++total_atracks;
  90       }
  91     }
  92     if( (fs->access() & ZIO_SEQUENTIAL) != 0 )
  93       set_pts_padding(-1);
  94     demuxer->seek_byte(0);
  95     restart();
  96     if( !iopened )
  97       fs->close_file();
  98   }
  99   allocate_slice_decoders();
 100   return ret;
 101 }
 102
 103 void zmpeg3_t::
 104 restart()
 105 {
 106   int i;
 107
 108   for( i=0; i<total_vtracks; ++i ) {
 109     vtrack_t *vtrk = vtrack[i];
 110     if( vtrk && vtrk->video ) {
 111       vtrk->current_position = 0;
 112       vtrk->reset_pts();
 113       vtrk->frame_cache->clear();
 114       vtrk->video->rewind_video(0);
 115     }
 116   }
 117
 118   for( i=0; i<total_atracks; ++i ) {
 119     atrack_t *atrk = atrack[i];
 120     if( atrk && atrk->audio ) {
 121       atrk->current_position = 0;
 122       atrk->reset_pts();
 123       atrk->audio->output_size = 0;
 124       atrk->audio->output_position = 0;
 125       atrk->audio->rewind_audio();
 126     }
 127   }
 128
 129   fs->restart();
 130 }
 131
 132 zmpeg3_t::
 133 zmpeg3_t(const char *path)
 134 #ifdef ZDVB
 135  : dvb(this)
 136 #endif
 137 {
 138   fs = new fs_t(this, path);
 139   cpus = 1;  log_errs = getenv("LOG_ERRS") ? 1 : 0;
 140   demuxer = new demuxer_t(this, 0, 0, -1);
 141 // for toc generation
 142   seekable = 0;
 143   memcpy(&palette[0], &def_palette[0], sizeof(def_palette));
 144   char *cp = getenv("PTS_PADDING");
 145   pts_padding = cp ? atoi(cp) : 1;
 146   index_bytes = 0x300000;
 147   cell_time = -1.;
 148   recd_fd = -1;
 149 }
 150
 151 zmpeg3_t::
 152 zmpeg3_t(const char *path, int &ret, int atype, const char *title_path)
 153 #ifdef ZDVB
 154  : dvb(this)
 155 #endif
 156 {
 157   fs = new fs_t(this, path, atype);
 158   ret = init(title_path);
 159 }
 160
 161 zmpeg3_t::
 162 zmpeg3_t(int fd, int &ret, int atype)
 163 #ifdef ZDVB
 164  : dvb(this)
 165 #endif
 166 {
 167   fs = new fs_t(this, fd, atype);
 168   ret = init();
 169 }
 170
 171 zmpeg3_t::
 172 zmpeg3_t(FILE *fp, int &ret, int atype)
 173 #ifdef ZDVB
 174  : dvb(this)
 175 #endif
 176 {
 177   fs = new fs_t(this, fp, atype);
 178   ret = init();
 179 }
 180
 181 zmpeg3_t::
 182 ~zmpeg3_t()
 183 {
 184   int i;
 185   int debug = 0;
 186
 187   if( debug ) zmsg("0\n");
 188   stop_record();
 189   delete_slice_decoders();
 190
 191   if( debug ) zmsg("1\n");
 192   for( i=0; i<total_stracks; ++i )
 193     delete strack[i];
 194
 195   if( debug ) zmsg("2\n");
 196   for( i=0; i<total_atracks; ++i )
 197     delete atrack[i];
 198
 199   if( debug ) zmsg("3\n");
 200   for( i=0; i<total_vtracks; ++i )
 201     delete vtrack[i];
 202
 203   if( debug ) zmsg("4\n");
 204   delete demuxer;
 205   delete fs;
 206   if( playinfo ) delete playinfo;
 207
 208   if( debug ) zmsg("5\n");
 209   if( frame_offsets ) {
 210     for( i=0; i<total_vtracks; ++i ) {
 211       delete [] frame_offsets[i];
 212       delete [] keyframe_numbers[i];
 213     }
 214
 215     if( debug ) zmsg("6\n");
 216     delete [] frame_offsets;
 217     delete [] keyframe_numbers;
 218     delete [] total_frame_offsets;
 219     delete [] total_keyframe_numbers;
 220     delete [] video_eof;
 221   }
 222
 223   if( debug ) zmsg("7\n");
 224   if( sample_offsets ) {
 225     for( i=0; i<total_atracks; ++i )
 226       delete [] sample_offsets[i];
 227
 228     delete [] sample_offsets;
 229     delete [] total_sample_offsets;
 230   }
 231
 232   if( debug ) zmsg("8\n");
 233   delete [] channel_counts;
 234   delete [] nudging;
 235   delete [] total_samples;
 236   delete [] audio_eof;
 237
 238   if( debug ) zmsg("9\n");
 239   if( indexes ) {
 240     for( i=0; i<total_indexes; ++i )
 241       delete indexes[i];
 242
 243     if( debug ) zmsg("10\n");
 244     delete [] indexes;
 245   }
 246   bitfont_t::destroy_fonts();
 247 }
 248
 249
 250 zmpeg3_t:: index_t::
 251 index_t()
 252 {
 253   index_zoom = 1;
 254 }
 255
 256 zmpeg3_t:: index_t::
 257 ~index_t()
 258 {
 259   for( int i=0;i<index_channels; ++i )
 260     delete [] index_data[i];
 261   delete [] index_data;
 262 }
 263
 264 // Return number of tracks in the table of contents
 265 int zmpeg3_t::
 266 index_tracks()
 267 {
 268   return total_indexes;
 269 }
 270
 271 // Return number of channels in track
 272 int zmpeg3_t::
 273 index_channels(int track)
 274 {
 275   if( track<0 || track>=total_indexes ) return 0;
 276   return indexes[track]->index_channels;
 277 }
 278
 279 // Return zoom factor of index
 280 int zmpeg3_t::
 281 index_zoom()
 282 {
 283   return !total_indexes ? 0 : indexes[0]->index_zoom;
 284 }
 285
 286 // Number of high/low pairs in a channel of the track
 287 int zmpeg3_t::
 288 index_size(int track)
 289 {
 290   if( track<0 || track>=total_indexes ) return 0;
 291   int size = indexes[track]->index_size;
 292   if( track < total_atracks && atrack[track]->nudge > 0 )
 293     size -= atrack[track]->nudge / indexes[0]->index_zoom;
 294   return size;
 295 }
 296
 297 // Get data for one index channel
 298 float* zmpeg3_t::
 299 index_data(int track, int channel)
 300 {
 301   if( track<0 || track>=total_indexes ) return 0;
 302   float *data = indexes[track]->index_data[channel];
 303   if( track < total_atracks && atrack[track]->nudge > 0 )
 304     data += (atrack[track]->nudge / indexes[0]->index_zoom) * 2;
 305   return data;
 306 }
 307
 308 zstrack_t* zmpeg3_t::
 309 get_strack_id(int id, video_t *vid)
 310 {
 311   for( int i=0; i<total_stracks; ++i ) {
 312     strack_t *strk = strack[i];
 313     if( strk->video && strk->video != vid ) continue;
 314     if( strk->id == id ) return strack[i];
 315   }
 316   return 0;
 317 }
 318
 319 zstrack_t* zmpeg3_t::
 320 get_strack(int number)
 321 {
 322   if( number >= total_stracks || number < 0 ) return 0;
 323   return strack[number];
 324 }
 325
 326 zstrack_t* zmpeg3_t::
 327 create_strack(int id, zvideo_t *vid)
 328 {
 329   int i, j;
 330   strack_t *strk = 0;
 331
 332   if( !(strk=get_strack_id(id, vid)) ) {
 333     strk = new strack_t(id, vid);
 334     for( i=0; i<total_stracks; ++i ) {
 335       /* Search for first ID > current id */
 336       if( strack[i]->id > id ) {
 337         /* Shift back 1 */
 338         for( j=total_stracks; --j>=i; )
 339           strack[j+1] = strack[j];
 340         break;
 341       }
 342     }
 343
 344 /* Store in table */
 345     strack[i] = strk;
 346     ++total_stracks;
 347   }
 348
 349   return strk;
 350 }
 351
 352 int zmpeg3_t::
 353 show_subtitle(int stream, int strk)
 354 {
 355   int result = -1;
 356   if( stream>=0 && stream<total_vtracks ) {
 357     vtrack_t *vtrk = vtrack[stream];
 358     if( vtrk && vtrk->video )
 359       result = vtrk->video->show_subtitle(strk);
 360   }
 361   return result;
 362 }
 363
 364 static inline int is_toc_(uint32_t bits)
 365 {
 366   return (bits == zmpeg3_t::TOC_PREFIX);
 367 }
 368
 369
 370 static inline int is_ifo_(uint32_t bits)
 371 {
 372   return (bits == zmpeg3_t::IFO_PREFIX);
 373 }
 374
 375 static inline int is_transport_(uint32_t bits)
 376 {
 377   return (((bits >> 24) & 0xff) == zmpeg3_t::SYNC_BYTE);
 378 }
 379
 380 static inline int is_bd_(uint32_t bits1, uint32_t bits2, char *ext)
 381 {
 382   return (((bits2 >> 24) & 0xff) == zmpeg3_t::SYNC_BYTE) &&
 383     ( !ext || (ext &&
 384       (!strncasecmp(ext, ".m2ts", 5) ||
 385        !strncasecmp(ext, ".mts", 4))) );
 386 }
 387
 388 static inline int is_program_(uint32_t bits)
 389 {
 390   return (bits == zmpeg3_t::PACK_START_CODE);
 391 }
 392
 393 static inline int is_mpeg_audio_(uint32_t bits)
 394 {
 395   return (bits & 0xfff00000) == 0xfff00000 ||
 396          (bits & 0xffff0000) == 0xffe30000 ||
 397          ((bits >> 8) == zmpeg3_t::ID3_PREFIX) ||
 398          (bits == zmpeg3_t::RIFF_CODE);
 399 }
 400
 401 static inline int is_mpeg_video_(uint32_t bits)
 402 {
 403   return (bits == zmpeg3_t::SEQUENCE_START_CODE ||
 404           bits == zmpeg3_t::PICTURE_START_CODE);
 405 }
 406
 407 static inline int is_ac3_(uint32_t bits)
 408 {
 409   return (((bits & 0xffff0000) >> 16) == zmpeg3_t::AC3_START_CODE);
 410 }
 411
 412 int zmpeg3_t::
 413 check_sig(char *path)
 414 {
 415   int result = 0;
 416   fs_t *fs = new fs_t(0, path);
 417
 418   if( !fs->open_file() ) { /* File found */
 419     char *ext = strrchr(path, '.');
 420     uint32_t bits = fs->read_uint32();
 421     uint32_t bits2 = fs->read_uint32();
 422
 423     /* pre-approved suffixes */
 424     if( ext && !strncasecmp(ext, ".mp3", 4) ) {
 425       result = 1;
 426     }
 427     /* Test header */
 428     else if( bits == TOC_PREFIX ) {
 429       result = 1;
 430     }
 431     /* Blu-Ray or AVC-HD*/
 432     else if( is_bd_(bits, bits2, ext) ) {
 433       result = 1;
 434     }
 435     else if( (((bits >> 24) & 0xff) == zmpeg3_t::SYNC_BYTE ) ||
 436              (bits == zmpeg3_t::PACK_START_CODE) ||
 437              ((bits & 0xfff00000) == 0xfff00000) ||
 438              ((bits & 0xffff0000) == 0xffe30000) ||
 439              (bits == zmpeg3_t::SEQUENCE_START_CODE) ||
 440              (bits == zmpeg3_t::PICTURE_START_CODE) ||
 441              (((bits & 0xffff0000) >> 16) == zmpeg3_t::AC3_START_CODE) ||
 442              ((bits >> 8) == zmpeg3_t::ID3_PREFIX) ||
 443              (bits == zmpeg3_t::RIFF_CODE) ||
 444              (bits == zmpeg3_t::IFO_PREFIX)) {
 445       result = 1;
 446
 447       /* Test file extension. */
 448       if( ext ) {  ++ext;
 449         if( strcasecmp(ext, "ifo") &&
 450             strcasecmp(ext, "mp2") &&
 451             strcasecmp(ext, "mp3") &&
 452             strcasecmp(ext, "m1v") &&
 453             strcasecmp(ext, "m2v") &&
 454             strcasecmp(ext, "m2s") &&
 455             strcasecmp(ext, "mpg") &&
 456             strcasecmp(ext, "vob") &&
 457             strcasecmp(ext, "ts") &&
 458             strcasecmp(ext, "vts") &&
 459             strcasecmp(ext, "mpeg") &&
 460             strcasecmp(ext, "m2t") &&
 461             strcasecmp(ext, "ac3") )
 462           result = 0;
 463       }
 464     }
 465     fs->close_file();
 466   }
 467
 468   delete fs;
 469   return result;
 470 }
 471
 472 int zmpeg3_t::
 473 calculate_packet_size()
 474 {
 475   if( is_transport_stream() )
 476     return is_bd() ?  BD_PACKET_SIZE : TS_PACKET_SIZE;
 477   if( is_program_stream() )
 478     return 0;
 479   if( is_audio_stream() || is_video_stream() )
 480     return DVD_PACKET_SIZE;
 481   zerr("undefined stream type.\n");
 482   return -1;
 483 }
 484
 485 int zmpeg3_t::
 486 get_file_type(int *toc_atracks, int *toc_vtracks, const char *title_path)
 487 {
 488   int result = 0;
 489   file_type = 0;
 490   uint32_t bits = fs->read_uint32();
 491   uint32_t bits2 = fs->read_uint32();
 492
 493   /* TOC  */
 494   if( is_toc_(bits) ) {
 495     /* Table of contents for another title set */
 496     result = toc_atracks && toc_vtracks ?
 497       read_toc(toc_atracks, toc_vtracks, title_path) : 1;
 498     if( result ) fs->close_file();
 499   }
 500   else if( is_ifo_(bits) ) {
 501   /* IFO file */
 502     if( !read_ifo() )
 503       file_type = FT_PROGRAM_STREAM | FT_IFO_FILE;
 504     fs->close_file();
 505   }
 506   else if( is_bd_(bits,bits2,0) ) {
 507     file_type = FT_TRANSPORT_STREAM | FT_BD_FILE;
 508   }
 509   /* Transport stream */
 510   else if( is_transport_(bits) ) {
 511     file_type = FT_TRANSPORT_STREAM;
 512   }
 513   /* Program stream */
 514   /* Determine packet size empirically */
 515   else if( is_program_(bits) ) {
 516     file_type = FT_PROGRAM_STREAM;
 517   }
 518   /* MPEG Audio only */
 519   else if( is_mpeg_audio_(bits) ) {
 520     file_type = FT_AUDIO_STREAM;
 521   }
 522   /* Video only */
 523   else if( is_mpeg_video_(bits) ) {
 524     file_type = FT_VIDEO_STREAM;
 525   }
 526   /* AC3 Audio only */
 527   else if( is_ac3_(bits) ) {
 528     file_type = FT_AUDIO_STREAM;
 529   }
 530   else {
 531     const char *ext = strrchr(fs->path, '.');
 532     if( ext ) {
 533       if( !strncasecmp(ext, ".mp3", 4) ) {
 534         file_type = FT_AUDIO_STREAM;
 535       }
 536     }
 537   }
 538 //zmsgs("2 %x\n", file_type);
 539   if( !file_type ) {
 540     zerr("not a readable stream.\n");
 541     if( !result ) result = ERR_UNDEFINED_ERROR;
 542   }
 543   else
 544     packet_size = calculate_packet_size();
 545   return result;
 546 }
 547
 548 int zmpeg3_t::
 549 set_pts_padding(int v)
 550 {
 551   int ret = pts_padding;
 552   pts_padding = v;
 553   if( pts_padding >= 0 ) {
 554     for( int vtk=0; vtk<total_vtracks; ++vtk )
 555       vtrack[vtk]->pts_starttime = -1.;
 556     for( int atk=0; atk<total_atracks; ++atk )
 557       atrack[atk]->pts_starttime = -1.;
 558   }
 559   else {
 560     for( int vtk=0; vtk<total_vtracks; ++vtk )
 561       vtrack[vtk]->pts_starttime = vtrack[vtk]->pts_offset = 0.;
 562     for( int atk=0; atk<total_atracks; ++atk )
 563       atrack[atk]->pts_starttime = atrack[atk]->pts_offset = 0.;
 564   }
 565   return ret;
 566 }
 567
 568 int zmpeg3_t::
 569 set_cpus(int cpus)
 570 {
 571   this->cpus = cpus;
 572   int i;
 573   for( i=0; i<total_vtracks; ++i )
 574     vtrack[i]->video->set_cpus(cpus);
 575   return 0;
 576 }
 577
 578 int zmpeg3_t::
 579 has_audio()
 580 {
 581   return total_atracks > 0;
 582 }
 583
 584 int zmpeg3_t::
 585 total_astreams()
 586 {
 587   return total_atracks;
 588 }
 589
 590 int zmpeg3_t::
 591 audio_channels(int stream)
 592 {
 593   return stream>=0 && stream<total_atracks ?
 594     atrack[stream]->channels : -1;
 595 }
 596
 597 double zmpeg3_t::
 598 sample_rate(int stream)
 599 {
 600   return stream>=0 && stream<total_atracks ?
 601     (double)atrack[stream]->sample_rate : -1.;
 602 }
 603
 604 long zmpeg3_t::
 605 get_sample(int stream)
 606 {
 607   return stream>=0 && stream<total_atracks ?
 608     atrack[stream]->current_position : -1;
 609 }
 610
 611 int zmpeg3_t::
 612 set_sample(long sample, int stream)
 613 {
 614   int result = 1;
 615   if( stream>=0 && stream<total_atracks ) {
 616     atrack_t *atrk = atrack[stream];
 617     if( atrk && atrk->audio ) {
 618 //zmsgs("1 %d %ld\n", atrk->current_position, sample);
 619       if( atrk->current_position != sample ) {
 620         atrk->current_position = sample;
 621         atrk->audio->seek_sample(sample);
 622       }
 623       result = 0;
 624     }
 625   }
 626   return result;
 627 }
 628
 629 long zmpeg3_t::
 630 audio_nudge(int stream)
 631 {
 632   long result = 0;
 633   if( stream>=0 && stream<total_atracks ) {
 634     atrack_t *atrk = atrack[stream];
 635     if( atrk ) result = atrk->nudge;
 636   }
 637   return result;
 638 }
 639
 640 long zmpeg3_t::
 641 audio_samples(int stream)
 642 {
 643   long result = -1;
 644   if( stream>=0 && stream<total_atracks ) {
 645     atrack_t *atrk = atrack[stream];
 646     if( atrk ) result = atrk->total_samples;
 647   }
 648   return result;
 649 }
 650
 651 const char* zmpeg3_t::
 652 audio_format(int stream)
 653 {
 654   const char *result = 0;
 655   if( stream>=0 && stream<total_atracks ) {
 656     switch( atrack[stream]->format ) {
 657     case afmt_IGNORE:  result = "Ignore";  break;
 658     case afmt_UNKNOWN: result = "Unknown"; break;
 659     case afmt_MPEG:    result = "MPEG";    break;
 660     case afmt_AC3:     result = "AC3";     break;
 661     case afmt_PCM:     result = "PCM";     break;
 662     case afmt_AAC:     result = "AAC";     break;
 663     case afmt_JESUS:   result = "Vorbis";  break;
 664     default:           result = "Undef";   break;
 665     }
 666   }
 667   return result;
 668 }
 669
 670 int zmpeg3_t::
 671 has_video()
 672 {
 673   return total_vtracks > 0;
 674 }
 675
 676 int zmpeg3_t::
 677 total_vstreams()
 678 {
 679   return total_vtracks;
 680 }
 681
 682 int zmpeg3_t::
 683 video_width(int stream)
 684 {
 685   int result = -1;
 686   if( stream>=0 && stream<total_vtracks ) {
 687     vtrack_t *vtrk = vtrack[stream];
 688     if( vtrk ) result = vtrk->width;
 689   }
 690   return result;
 691 }
 692
 693 int zmpeg3_t::
 694 video_height(int stream)
 695 {
 696   int result = -1;
 697   if( stream>=0 && stream<total_vtracks ) {
 698     vtrack_t *vtrk = vtrack[stream];
 699     if( vtrk ) result = vtrk->height;
 700   }
 701   return result;
 702 }
 703
 704 int zmpeg3_t::
 705 coded_width(int stream)
 706 {
 707   int result = -1;
 708   if( stream>=0 && stream<total_vtracks ) {
 709     vtrack_t *vtrk = vtrack[stream];
 710     if( vtrk )
 711       result = vtrk->video->coded_picture_width;
 712   }
 713   return result;
 714 }
 715
 716 int zmpeg3_t::
 717 coded_height(int stream)
 718 {
 719   int result = -1;
 720   if( stream>=0 && stream<total_vtracks ) {
 721     vtrack_t *vtrk = vtrack[stream];
 722     if( vtrk )
 723       result = vtrk->video->coded_picture_height;
 724   }
 725   return result;
 726 }
 727
 728 int zmpeg3_t::
 729 video_pid(int stream)
 730 {
 731   int result = -1;
 732   if( stream>=0 && stream<total_vtracks ) {
 733     vtrack_t *vtrk = vtrack[stream];
 734     if( vtrk ) result = vtrk->pid;
 735   }
 736   return result;
 737 }
 738
 739 float zmpeg3_t::
 740 aspect_ratio(int stream)
 741 {
 742   float result = 0.0;
 743   if( stream>=0 && stream<total_vtracks ) {
 744     vtrack_t *vtrk = vtrack[stream];
 745     if( vtrk ) result = vtrk->aspect_ratio;
 746   }
 747   return result;
 748 }
 749
 750 double zmpeg3_t::
 751 frame_rate(int stream)
 752 {
 753   double result = -1.0;
 754   if( stream>=0 && stream<total_vtracks ) {
 755     vtrack_t *vtrk = vtrack[stream];
 756     if( vtrk ) result = vtrk->frame_rate;
 757   }
 758   return result;
 759 }
 760
 761 long zmpeg3_t::
 762 video_frames(int stream)
 763 {
 764   long result = -1;
 765   if( stream>=0 && stream<total_vtracks ) {
 766     vtrack_t *vtrk = vtrack[stream];
 767     if( vtrk ) result = vtrk->total_frames;
 768   }
 769   return result;
 770 }
 771
 772 long zmpeg3_t::
 773 get_frame(int stream)
 774 {
 775   long result = -1;
 776   if( stream>=0 && stream<total_vtracks ) {
 777     vtrack_t *vtrk = vtrack[stream];
 778     if( vtrk ) result = vtrk->current_position;
 779   }
 780   return result;
 781 }
 782
 783 int zmpeg3_t::
 784 set_frame(long frame, int stream)
 785 {
 786   int result = -1;
 787   if( stream>=0 && stream<total_vtracks ) {
 788     vtrack_t *vtrk = vtrack[stream];
 789     if( vtrk && vtrk->video ) {
 790       if( vtrk->current_position != frame ) {
 791         vtrk->current_position = frame;
 792         vtrk->video->seek_frame(frame);
 793       }
 794       result = 0;
 795     }
 796   }
 797   return result;
 798 }
 799
 800 int zmpeg3_t::
 801 seek_byte(int64_t byte)
 802 {
 803   int i;
 804
 805   for( i=0; i<total_vtracks; ++i ) {
 806     vtrack_t *vtrk = vtrack[i];
 807     if( vtrk && vtrk->video ) {
 808       vtrk->current_position = 0;
 809       if( byte )
 810         vtrk->video->seek_byte(byte);
 811       else
 812         vtrk->video->rewind_video();
 813     }
 814   }
 815
 816   for( i=0; i<total_atracks; ++i ) {
 817     atrack_t *atrk = atrack[i];
 818     if( atrk && atrk->audio ) {
 819       atrk->current_position = 0;
 820       atrk->audio->seek_byte(byte);
 821     }
 822   }
 823
 824   return 0;
 825 }
 826
 827 int zmpeg3_t::
 828 previous_frame(int stream)
 829 {
 830   int result = 1;
 831
 832   if( stream>=0 && stream<total_vtracks ) {
 833     vtrack_t *vtrk = vtrack[stream];
 834     if( vtrk && vtrk->video ) {
 835       last_type_read = 2;
 836       last_stream_read = stream;
 837       result = vtrk->video->previous_frame();
 838     }
 839   }
 840   return result;
 841 }
 842
 843 int64_t zmpeg3_t::
 844 tell_byte()
 845 {
 846   int64_t result = -1;
 847   if( last_type_read == 1 )
 848     result = atrack[last_stream_read]->demuxer->tell_byte();
 849   else if( last_type_read == 2 )
 850     result =vtrack[last_stream_read]->demuxer->tell_byte();
 851   return result;
 852 }
 853
 854 int64_t zmpeg3_t::
 855 get_bytes()
 856 {
 857   return demuxer->movie_size();
 858 }
 859
 860 double zmpeg3_t::
 861 get_audio_time(int stream)
 862 {
 863   double atime = -1.0;
 864   if( stream >= 0 && stream < total_atracks ) {
 865     double samplerate = sample_rate(stream);
 866     if( samplerate > 0. ) {
 867       int64_t sample = get_sample(stream);
 868       if( !pts_padding || is_audio_stream() || is_video_stream() ) {
 869         atime = sample / samplerate;
 870       }
 871       else {
 872         atime = atrack[stream]->audio_time +
 873           (sample - atrack[stream]->pts_position) / samplerate;
 874       }
 875     }
 876   }
 877   return atime;
 878 }
 879
 880 double zmpeg3_t::
 881 get_video_time(int stream)
 882 {
 883   double vtime = -1.0;
 884   if( stream >= 0 && stream < total_vtracks ) {
 885     double framerate = frame_rate(stream);
 886     if( !pts_padding || is_audio_stream() || is_video_stream() ) {
 887       if( framerate > 0. )
 888         vtime = (double)get_frame(stream) / framerate;
 889     }
 890     else {
 891       vtime = vtrack[stream]->video_time;
 892       if( vtime >= 0. && framerate > 0. )
 893         vtime += (get_frame(stream) - vtrack[stream]->pts_position) / framerate;
 894     }
 895   }
 896   return vtime;
 897 }
 898
 899 /* pts timecode available only in transport stream */
 900 double zmpeg3_t::
 901 get_time()
 902 {
 903   double time = 0;
 904   if( last_type_read == 1 )
 905     time = get_audio_time(last_stream_read);
 906   else if( last_type_read == 2 )
 907     time = get_video_time(last_stream_read);
 908   return time;
 909 }
 910
 911 int zmpeg3_t::
 912 get_total_vts_titles()
 913 {
 914   return total_vts_titles;
 915 }
 916
 917 int zmpeg3_t::
 918 set_vts_title(int title)
 919 {
 920   int result = vts_title;
 921   if( title >= 0 )
 922     vts_title = title;
 923   return result;
 924 }
 925
 926 int zmpeg3_t::
 927 get_total_interleaves()
 928 {
 929   return total_interleaves;
 930 }
 931
 932 int zmpeg3_t::
 933 set_interleave(int inlv)
 934 {
 935   int result = interleave;
 936   if( inlv >= 0 )
 937     interleave = inlv;
 938   return result;
 939 }
 940
 941 int zmpeg3_t::
 942 set_angle(int a)
 943 {
 944   int result = angle;
 945   if( a >= 0 )
 946     angle = a;
 947   return result;
 948 }
 949
 950 int zmpeg3_t::
 951 set_program(int no)
 952 {
 953   int result = set_vts_title()*100 + set_angle()*10 + set_interleave();
 954   if( no >= 0 ) {
 955     set_vts_title(no / 100);
 956     set_angle((no/10) % 10);
 957     set_interleave(no % 10);
 958   }
 959   return result;
 960 }
 961
 962 int zmpeg3_t::
 963 get_cell_time(int no, double &time)
 964 {
 965   int result = 1, i = 0;
 966   zcell_t *cell = 0;
 967   while( no >= 0 ) {
 968     result = demuxer->get_cell(i, cell);
 969     if( result < 0 ) return result;
 970     if( result > 0 ) i = cell->cell_no;
 971     ++i;  --no;
 972   }
 973   time = cell->cell_time;
 974   return 0;
 975 }
 976
 977 int zmpeg3_t::
 978 end_of_audio(int stream)
 979 {
 980   int result = 1;
 981   if( stream>=0 && stream<total_atracks ) {
 982     atrack_t *atrk = atrack[stream];
 983     if( atrk && atrk->demuxer )
 984       result = atrk->demuxer->eof();
 985   }
 986   return result;
 987 }
 988
 989 int zmpeg3_t::
 990 end_of_video(int stream)
 991 {
 992   int result = 1;
 993   if( stream>=0 && stream<total_vtracks ) {
 994     vtrack_t *vtrk = vtrack[stream];
 995     if( vtrk && vtrk->demuxer )
 996       result = vtrk->demuxer->eof();
 997   }
 998   return result;
 999 }
1000
1001 int zmpeg3_t::
1002 drop_frames(long frames, int stream)
1003 {
1004   int result = -1;
1005   if( stream>=0 && stream<total_vtracks ) {
1006     vtrack_t *vtrk = vtrack[stream];
1007     if( vtrk && vtrk->video ) {
1008       result = vtrk->video->drop_frames(frames, 0);
1009       if( frames > 0 )
1010         vtrk->current_position += frames;
1011       last_type_read = 2;
1012       last_stream_read = stream;
1013     }
1014   }
1015   return result;
1016 }
1017
1018 int zmpeg3_t::
1019 colormodel(int stream)
1020 {
1021   int result = -1;
1022   if( stream>=0 && stream<total_vtracks ) {
1023     vtrack_t *vtrk = vtrack[stream];
1024     if( vtrk && vtrk->video )
1025       result = vtrk->video->colormodel();
1026   }
1027   return result;
1028 }
1029
1030 int zmpeg3_t::
1031 set_rowspan(int bytes, int stream)
1032 {
1033   int result = 1;
1034   if( stream>=0 && stream<total_vtracks ) {
1035     vtrack_t *vtrk = vtrack[stream];
1036     if( vtrk && vtrk->video ) {
1037       vtrk->video->row_span = bytes;
1038       result = 0;
1039     }
1040   }
1041   return result;
1042 }
1043
1044
1045 int zmpeg3_t::
1046 read_frame(uint8_t **output_rows,
1047     int in_x, int in_y, int in_w, int in_h,
1048     int out_w, int out_h, int color_model, int stream)
1049 {
1050   int result = -1;
1051 //zmsgs("1 %d\n", vtrack[stream]->current_position);
1052   if( stream>=0 && stream<total_vtracks ) {
1053     vtrack_t *vtrk = vtrack[stream];
1054     if( vtrk && vtrk->video ) {
1055       result = vtrk->video->read_frame(output_rows,
1056           in_x, in_y, in_w, in_h, out_w, out_h, color_model);
1057 //zmsg(" 2\n");
1058       last_type_read = 2;
1059       last_stream_read = stream;
1060       vtrk->current_position++;
1061     }
1062   }
1063 //zmsgs("2 %d\n", vtrack[stream]->current_position);
1064   return result;
1065 }
1066
1067 int zmpeg3_t::
1068 read_yuvframe(char *y_output, char *u_output, char *v_output,
1069     int in_x, int in_y, int in_w, int in_h, int stream)
1070 {
1071   int result = -1;
1072 //zmsg("1\n");
1073   if( stream>=0 && stream<total_vtracks ) {
1074     vtrack_t *vtrk = vtrack[stream];
1075     if( vtrk && vtrk->video ) {
1076       result = vtrk->video->read_yuvframe(y_output, u_output, v_output,
1077           in_x, in_y, in_w, in_h);
1078       last_type_read = 2;
1079       last_stream_read = stream;
1080       vtrk->current_position++;
1081     }
1082   }
1083 //zmsg("100\n");
1084   return result;
1085 }
1086
1087 int zmpeg3_t::
1088 read_yuvframe_ptr(char **y_output, char **u_output, char **v_output,
1089     int stream)
1090 {
1091   int result = -1;
1092   if( stream>=0 && stream<total_vtracks ) {
1093     vtrack_t *vtrk = vtrack[stream];
1094     if( vtrk && vtrk->video ) {
1095       result = vtrk->video->read_yuvframe_ptr(y_output, u_output, v_output);
1096       last_type_read = 2;
1097       last_stream_read = stream;
1098       vtrk->current_position++;
1099     }
1100   }
1101   return result;
1102 }
1103
1104 int zmpeg3_t::
1105 read_audio(void *output, int type, int channel, long samples, int stream)
1106 {
1107   int result = -1;
1108   if( stream>=0 && stream<total_atracks ) {
1109     atrack_t *atrk = atrack[stream];
1110     if( atrk && atrk->audio ) {
1111       atrk->audio->update_audio_history();
1112       result = atrk->audio->decode_audio(output, type, channel, samples);
1113       last_type_read = 1;
1114       last_stream_read = stream;
1115       atrk->current_position += samples;
1116     }
1117   }
1118   return result;
1119 }
1120
1121 int zmpeg3_t::
1122 read_audio(double *output_d, int channel, long samples, int stream)
1123 {
1124   return read_audio((void *)output_d, atyp_DOUBLE, channel, samples, stream);
1125 }
1126
1127 int zmpeg3_t::
1128 read_audio(float *output_f, int channel, long samples, int stream)
1129 {
1130   return read_audio((void *)output_f, atyp_FLOAT, channel, samples, stream);
1131 }
1132
1133 int zmpeg3_t::
1134 read_audio(int *output_i, int channel, long samples, int stream)
1135 {
1136   return read_audio((void *)output_i, atyp_INT, channel, samples, stream);
1137 }
1138
1139 int zmpeg3_t::
1140 read_audio(short *output_s, int channel, long samples, int stream)
1141 {
1142   return read_audio((void *)output_s, atyp_SHORT, channel, samples, stream);
1143 }
1144
1145 int zmpeg3_t::
1146 reread_audio(void *output, int atyp, int channel, long samples, int stream)
1147 {
1148   int result = -1;
1149   if( stream>=0 && stream<total_atracks ) {
1150     atrack_t *atrk = atrack[stream];
1151     if( atrk && atrk->audio ) {
1152       set_sample( atrk->current_position-samples, stream);
1153       result = atrk->audio->decode_audio(output, atyp, channel, samples);
1154       last_type_read = 1;
1155       last_stream_read = stream;
1156       atrk->current_position += samples;
1157     }
1158   }
1159   return result;
1160 }
1161
1162 int zmpeg3_t::
1163 reread_audio(double *output_d, int channel, long samples, int stream)
1164 {
1165   return reread_audio((void *)output_d, atyp_DOUBLE, channel, samples, stream);
1166 }
1167
1168 int zmpeg3_t::
1169 reread_audio(float *output_f, int channel, long samples, int stream)
1170 {
1171   return reread_audio((void *)output_f, atyp_FLOAT, channel, samples, stream);
1172 }
1173
1174 int zmpeg3_t::
1175 reread_audio(int *output_i, int channel, long samples, int stream)
1176 {
1177   return reread_audio((void *)output_i, atyp_INT, channel, samples, stream);
1178 }
1179
1180 int zmpeg3_t::
1181 reread_audio(short *output_s, int channel, long samples, int stream)
1182 {
1183   return reread_audio((void *)output_s, atyp_SHORT, channel, samples, stream);
1184 }
1185
1186
1187 int zmpeg3_t::
1188 read_audio_chunk(uint8_t *output, long *size, long max_size, int stream)
1189 {
1190   int result = -1;
1191   if( stream>=0 && stream<total_atracks ) {
1192     atrack_t *atrk = atrack[stream];
1193     if( atrk && atrk->audio ) {
1194       result = atrk->audio->read_raw(output, size, max_size);
1195       last_type_read = 1;
1196       last_stream_read = stream;
1197     }
1198   }
1199   return result;
1200 }
1201
1202 int zmpeg3_t::
1203 read_video_chunk( uint8_t *output, long *size, long max_size, int stream)
1204 {
1205   int result = -1;
1206   if( stream>=0 && stream<total_vtracks ) {
1207     vtrack_t *vtrk = vtrack[stream];
1208     if( vtrk && vtrk->video ) {
1209       result = vtrk->video->read_raw(output, size, max_size);
1210       last_type_read = 2;
1211       last_stream_read = stream;
1212     }
1213   }
1214   return result;
1215 }
1216
1217 int64_t zmpeg3_t::
1218 memory_usage()
1219 {
1220   int64_t result = 0;
1221   for( int i=0; i<total_vtracks; ++i )
1222     if( vtrack[i]->frame_cache )
1223       result += vtrack[i]->frame_cache->memory_usage();
1224   return result;
1225 }
1226
1227 int zmpeg3_t::
1228 start_record(int fd, int bsz)
1229 {
1230   if( recd_fd >= 0 ) return 1;
1231   struct stat64 st;
1232   memset(&st, 0, sizeof(st));
1233   if( fstat64(fd, &st) < 0 ) return 1;
1234   recd_fd = fd;
1235   recd_pos = st.st_size;
1236   if (fs->start_record(bsz)) return recd_fd = -1;
1237   return 0;
1238 }
1239 int zmpeg3_t::
1240 stop_record()
1241 {
1242   if( fs->stop_record() ) return 1;
1243   recd_fd = -1;
1244   return 0;
1245 }
1246
1247 void zmpeg3_t::
1248 write_record(uint8_t *data, int len)
1249 {
1250   if( recd_fd < 0 ) return;
1251   if( write(recd_fd, data, len) < 0 ) {
1252     zmsgs("write err: %s\n",strerror(errno));
1253     return;
1254   }
1255   recd_pos += len;
1256 }
1257
1258 int zmpeg3_t::
1259 pause_reader(int v)
1260 {
1261   return fs->pause_reader(v);
1262 }
1263
1264 int zmpeg3_t::
1265 get_thumbnail(int trk, int64_t &frn, uint8_t *&t, int &w, int &h)
1266 {
1267   int result = -1;
1268   if( trk>=0 && trk<total_vtracks ) {
1269     vtrack_t *vtrk = vtrack[trk];
1270     if( vtrk ) {
1271       video_t *vid = vtrk->video;
1272       frn = vid->framenum;
1273       t = vid->tdat;
1274       w = 2*vid->mb_width;
1275       h = 2*vid->mb_height;
1276       result = 0;
1277     }
1278   }
1279   return result;
1280 }
1281
1282 int zmpeg3_t::
1283 set_thumbnail_callback(int trk, int skim, int thumb,
1284         zthumbnail_cb fn, void *p)
1285 {
1286   int result = 1;
1287   // all tracks, toc build
1288   if( trk == -1 )
1289     result = 0;
1290   // one track, commercials verify
1291   else if( trk >= 0 && trk<total_vtracks ) {
1292     vtrack_t *vtrk = vtrack[trk];
1293     if( vtrk ) {
1294       video_t *vid = vtrk->video;
1295       if( !(result=vid->seek_video()) ) {
1296         vid->skim = skim;
1297         vid->thumb = thumb;
1298         vid->ithumb = 0;
1299         result = 0;
1300       }
1301     }
1302   }
1303   if( !result ) {
1304     thumbnail_priv = p;
1305     thumbnail_fn = fn;
1306   }
1307   return result;
1308 }
1309
1310 int zmpeg3_t::
1311 set_cc_text_callback(int trk, zcc_text_cb fn)
1312 {
1313   int result = -1;
1314   if( trk>=0 && trk<total_vtracks ) {
1315     vtrack_t *vtrk = vtrack[trk];
1316     if( vtrk ) {
1317       video_t *vid = vtrk->video;
1318       vid->get_cc()->text_cb = fn;
1319       result = 0;
1320     }
1321   }
1322   return result;
1323 }
1324
1325 int64_t zmpeg3_t::
1326 calculate_source_date(char *path)
1327 {
1328   struct stat64 ostat;
1329   memset(&ostat,0,sizeof(struct stat64));
1330   return stat64(path, &ostat) < 0 ? 0 : ostat.st_mtime;
1331 }
1332
1333 int64_t zmpeg3_t::
1334 calculate_source_date(int fd)
1335 {
1336   struct stat64 ostat;
1337   memset(&ostat,0,sizeof(struct stat64));
1338   return fstat64(fd, &ostat) < 0 ? 0 : ostat.st_mtime;
1339 }
1340
1341 void zdebug(int n)
1342 {
1343   zmsgs("%d\n",n);
1344 }
1345
1346