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 */
29 init(const char *title_path)
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;
45 iopened = fs->is_open;
46 int ret = !iopened ? fs->open_file() : 0;
48 int toc_atracks = INT_MAX;
49 int toc_vtracks = INT_MAX;
50 ret = get_file_type(&toc_atracks, &toc_vtracks, title_path);
52 /* Start from scratch */
53 if( !demuxer->total_titles )
54 demuxer->create_title();
56 if( is_transport_stream() || is_program_stream() ) {
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;
65 /* Create audio tracks */
66 for( i=n=0; i<MAX_STREAMZ && total_atracks<toc_atracks; ++i ) {
67 int format = demuxer->astream_table[i];
69 atrack[total_atracks] = new_atrack_t(i, format, demuxer, n++);
70 if( atrack[total_atracks] ) ++total_atracks;
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;
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;
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;
92 if( (fs->access() & ZIO_SEQUENTIAL) != 0 )
94 demuxer->seek_byte(0);
99 allocate_slice_decoders();
108 for( i=0; i<total_vtracks; ++i ) {
109 vtrack_t *vtrk = vtrack[i];
110 if( vtrk && vtrk->video ) {
111 vtrk->current_position = 0;
113 vtrk->frame_cache->clear();
114 vtrk->video->rewind_video(0);
118 for( i=0; i<total_atracks; ++i ) {
119 atrack_t *atrk = atrack[i];
120 if( atrk && atrk->audio ) {
121 atrk->current_position = 0;
123 atrk->audio->output_size = 0;
124 atrk->audio->output_position = 0;
125 atrk->audio->rewind_audio();
133 zmpeg3_t(const char *path)
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
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;
152 zmpeg3_t(const char *path, int &ret, int atype, const char *title_path)
157 fs = new fs_t(this, path, atype);
158 ret = init(title_path);
162 zmpeg3_t(int fd, int &ret, int atype)
167 fs = new fs_t(this, fd, atype);
172 zmpeg3_t(FILE *fp, int &ret, int atype)
177 fs = new fs_t(this, fp, atype);
187 if( debug ) zmsg("0\n");
189 delete_slice_decoders();
191 if( debug ) zmsg("1\n");
192 for( i=0; i<total_stracks; ++i )
195 if( debug ) zmsg("2\n");
196 for( i=0; i<total_atracks; ++i )
199 if( debug ) zmsg("3\n");
200 for( i=0; i<total_vtracks; ++i )
203 if( debug ) zmsg("4\n");
206 if( playinfo ) delete playinfo;
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];
215 if( debug ) zmsg("6\n");
216 delete [] frame_offsets;
217 delete [] keyframe_numbers;
218 delete [] total_frame_offsets;
219 delete [] total_keyframe_numbers;
223 if( debug ) zmsg("7\n");
224 if( sample_offsets ) {
225 for( i=0; i<total_atracks; ++i )
226 delete [] sample_offsets[i];
228 delete [] sample_offsets;
229 delete [] total_sample_offsets;
232 if( debug ) zmsg("8\n");
233 delete [] channel_counts;
235 delete [] total_samples;
238 if( debug ) zmsg("9\n");
240 for( i=0; i<total_indexes; ++i )
243 if( debug ) zmsg("10\n");
246 bitfont_t::destroy_fonts();
259 for( int i=0;i<index_channels; ++i )
260 delete [] index_data[i];
261 delete [] index_data;
264 // Return number of tracks in the table of contents
268 return total_indexes;
271 // Return number of channels in track
273 index_channels(int track)
275 if( track<0 || track>=total_indexes ) return 0;
276 return indexes[track]->index_channels;
279 // Return zoom factor of index
283 return !total_indexes ? 0 : indexes[0]->index_zoom;
286 // Number of high/low pairs in a channel of the track
288 index_size(int track)
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;
297 // Get data for one index channel
299 index_data(int track, int channel)
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;
308 zstrack_t* zmpeg3_t::
309 get_strack_id(int id, video_t *vid)
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];
319 zstrack_t* zmpeg3_t::
320 get_strack(int number)
322 if( number >= total_stracks || number < 0 ) return 0;
323 return strack[number];
326 zstrack_t* zmpeg3_t::
327 create_strack(int id, zvideo_t *vid)
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 ) {
338 for( j=total_stracks; --j>=i; )
339 strack[j+1] = strack[j];
353 show_subtitle(int stream, int strk)
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);
364 static inline int is_toc_(uint32_t bits)
366 return (bits == zmpeg3_t::TOC_PREFIX);
370 static inline int is_ifo_(uint32_t bits)
372 return (bits == zmpeg3_t::IFO_PREFIX);
375 static inline int is_transport_(uint32_t bits)
377 return (((bits >> 24) & 0xff) == zmpeg3_t::SYNC_BYTE);
380 static inline int is_bd_(uint32_t bits1, uint32_t bits2, char *ext)
382 return (((bits2 >> 24) & 0xff) == zmpeg3_t::SYNC_BYTE) &&
384 (!strncasecmp(ext, ".m2ts", 5) ||
385 !strncasecmp(ext, ".mts", 4))) );
388 static inline int is_program_(uint32_t bits)
390 return (bits == zmpeg3_t::PACK_START_CODE);
393 static inline int is_mpeg_audio_(uint32_t bits)
395 return (bits & 0xfff00000) == 0xfff00000 ||
396 (bits & 0xffff0000) == 0xffe30000 ||
397 ((bits >> 8) == zmpeg3_t::ID3_PREFIX) ||
398 (bits == zmpeg3_t::RIFF_CODE);
401 static inline int is_mpeg_video_(uint32_t bits)
403 return (bits == zmpeg3_t::SEQUENCE_START_CODE ||
404 bits == zmpeg3_t::PICTURE_START_CODE);
407 static inline int is_ac3_(uint32_t bits)
409 return (((bits & 0xffff0000) >> 16) == zmpeg3_t::AC3_START_CODE);
413 check_sig(char *path)
416 fs_t *fs = new fs_t(0, path);
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();
423 /* pre-approved suffixes */
424 if( ext && !strncasecmp(ext, ".mp3", 4) ) {
428 else if( bits == TOC_PREFIX ) {
431 /* Blu-Ray or AVC-HD*/
432 else if( is_bd_(bits, bits2, ext) ) {
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)) {
447 /* Test file extension. */
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") )
473 calculate_packet_size()
475 if( is_transport_stream() )
476 return is_bd() ? BD_PACKET_SIZE : TS_PACKET_SIZE;
477 if( is_program_stream() )
479 if( is_audio_stream() || is_video_stream() )
480 return DVD_PACKET_SIZE;
481 zerr("undefined stream type.\n");
486 get_file_type(int *toc_atracks, int *toc_vtracks, const char *title_path)
490 uint32_t bits = fs->read_uint32();
491 uint32_t bits2 = fs->read_uint32();
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();
500 else if( is_ifo_(bits) ) {
503 file_type = FT_PROGRAM_STREAM | FT_IFO_FILE;
506 else if( is_bd_(bits,bits2,0) ) {
507 file_type = FT_TRANSPORT_STREAM | FT_BD_FILE;
509 /* Transport stream */
510 else if( is_transport_(bits) ) {
511 file_type = FT_TRANSPORT_STREAM;
514 /* Determine packet size empirically */
515 else if( is_program_(bits) ) {
516 file_type = FT_PROGRAM_STREAM;
518 /* MPEG Audio only */
519 else if( is_mpeg_audio_(bits) ) {
520 file_type = FT_AUDIO_STREAM;
523 else if( is_mpeg_video_(bits) ) {
524 file_type = FT_VIDEO_STREAM;
527 else if( is_ac3_(bits) ) {
528 file_type = FT_AUDIO_STREAM;
531 const char *ext = strrchr(fs->path, '.');
533 if( !strncasecmp(ext, ".mp3", 4) ) {
534 file_type = FT_AUDIO_STREAM;
538 //zmsgs("2 %x\n", file_type);
540 zerr("not a readable stream.\n");
541 if( !result ) result = ERR_UNDEFINED_ERROR;
544 packet_size = calculate_packet_size();
549 set_pts_padding(int v)
551 int ret = pts_padding;
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.;
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.;
573 for( i=0; i<total_vtracks; ++i )
574 vtrack[i]->video->set_cpus(cpus);
581 return total_atracks > 0;
587 return total_atracks;
591 audio_channels(int stream)
593 return stream>=0 && stream<total_atracks ?
594 atrack[stream]->channels : -1;
598 sample_rate(int stream)
600 return stream>=0 && stream<total_atracks ?
601 (double)atrack[stream]->sample_rate : -1.;
605 get_sample(int stream)
607 return stream>=0 && stream<total_atracks ?
608 atrack[stream]->current_position : -1;
612 set_sample(long sample, int stream)
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);
630 audio_nudge(int stream)
633 if( stream>=0 && stream<total_atracks ) {
634 atrack_t *atrk = atrack[stream];
635 if( atrk ) result = atrk->nudge;
641 audio_samples(int stream)
644 if( stream>=0 && stream<total_atracks ) {
645 atrack_t *atrk = atrack[stream];
646 if( atrk ) result = atrk->total_samples;
651 const char* zmpeg3_t::
652 audio_format(int stream)
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;
673 return total_vtracks > 0;
679 return total_vtracks;
683 video_width(int stream)
686 if( stream>=0 && stream<total_vtracks ) {
687 vtrack_t *vtrk = vtrack[stream];
688 if( vtrk ) result = vtrk->width;
694 video_height(int stream)
697 if( stream>=0 && stream<total_vtracks ) {
698 vtrack_t *vtrk = vtrack[stream];
699 if( vtrk ) result = vtrk->height;
705 coded_width(int stream)
708 if( stream>=0 && stream<total_vtracks ) {
709 vtrack_t *vtrk = vtrack[stream];
711 result = vtrk->video->coded_picture_width;
717 coded_height(int stream)
720 if( stream>=0 && stream<total_vtracks ) {
721 vtrack_t *vtrk = vtrack[stream];
723 result = vtrk->video->coded_picture_height;
729 video_pid(int stream)
732 if( stream>=0 && stream<total_vtracks ) {
733 vtrack_t *vtrk = vtrack[stream];
734 if( vtrk ) result = vtrk->pid;
740 aspect_ratio(int stream)
743 if( stream>=0 && stream<total_vtracks ) {
744 vtrack_t *vtrk = vtrack[stream];
745 if( vtrk ) result = vtrk->aspect_ratio;
751 frame_rate(int stream)
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;
762 video_frames(int stream)
765 if( stream>=0 && stream<total_vtracks ) {
766 vtrack_t *vtrk = vtrack[stream];
767 if( vtrk ) result = vtrk->total_frames;
773 get_frame(int stream)
776 if( stream>=0 && stream<total_vtracks ) {
777 vtrack_t *vtrk = vtrack[stream];
778 if( vtrk ) result = vtrk->current_position;
784 set_frame(long frame, int stream)
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);
801 seek_byte(int64_t byte)
805 for( i=0; i<total_vtracks; ++i ) {
806 vtrack_t *vtrk = vtrack[i];
807 if( vtrk && vtrk->video ) {
808 vtrk->current_position = 0;
810 vtrk->video->seek_byte(byte);
812 vtrk->video->rewind_video();
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);
828 previous_frame(int stream)
832 if( stream>=0 && stream<total_vtracks ) {
833 vtrack_t *vtrk = vtrack[stream];
834 if( vtrk && vtrk->video ) {
836 last_stream_read = stream;
837 result = vtrk->video->previous_frame();
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();
857 return demuxer->movie_size();
861 get_audio_time(int stream)
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;
872 atime = atrack[stream]->audio_time +
873 (sample - atrack[stream]->pts_position) / samplerate;
881 get_video_time(int stream)
884 if( stream >= 0 && stream < total_vtracks ) {
885 double framerate = frame_rate(stream);
886 if( !pts_padding || is_audio_stream() || is_video_stream() ) {
888 vtime = (double)get_frame(stream) / framerate;
891 vtime = vtrack[stream]->video_time;
892 if( vtime >= 0. && framerate > 0. )
893 vtime += (get_frame(stream) - vtrack[stream]->pts_position) / framerate;
899 /* pts timecode available only in transport stream */
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);
912 get_total_vts_titles()
914 return total_vts_titles;
918 set_vts_title(int title)
920 int result = vts_title;
927 get_total_interleaves()
929 return total_interleaves;
933 set_interleave(int inlv)
935 int result = interleave;
953 int result = set_vts_title()*100 + set_angle()*10 + set_interleave();
955 set_vts_title(no / 100);
956 set_angle((no/10) % 10);
957 set_interleave(no % 10);
963 get_cell_time(int no, double &time)
965 int result = 1, i = 0;
968 result = demuxer->get_cell(i, cell);
969 if( result < 0 ) return result;
970 if( result > 0 ) i = cell->cell_no;
973 time = cell->cell_time;
978 end_of_audio(int stream)
981 if( stream>=0 && stream<total_atracks ) {
982 atrack_t *atrk = atrack[stream];
983 if( atrk && atrk->demuxer )
984 result = atrk->demuxer->eof();
990 end_of_video(int stream)
993 if( stream>=0 && stream<total_vtracks ) {
994 vtrack_t *vtrk = vtrack[stream];
995 if( vtrk && vtrk->demuxer )
996 result = vtrk->demuxer->eof();
1002 drop_frames(long frames, int stream)
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);
1010 vtrk->current_position += frames;
1012 last_stream_read = stream;
1019 colormodel(int stream)
1022 if( stream>=0 && stream<total_vtracks ) {
1023 vtrack_t *vtrk = vtrack[stream];
1024 if( vtrk && vtrk->video )
1025 result = vtrk->video->colormodel();
1031 set_rowspan(int bytes, int stream)
1034 if( stream>=0 && stream<total_vtracks ) {
1035 vtrack_t *vtrk = vtrack[stream];
1036 if( vtrk && vtrk->video ) {
1037 vtrk->video->row_span = bytes;
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)
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);
1059 last_stream_read = stream;
1060 vtrk->current_position++;
1063 //zmsgs("2 %d\n", vtrack[stream]->current_position);
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)
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);
1079 last_stream_read = stream;
1080 vtrk->current_position++;
1088 read_yuvframe_ptr(char **y_output, char **u_output, char **v_output,
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);
1097 last_stream_read = stream;
1098 vtrk->current_position++;
1105 read_audio(void *output, int type, int channel, long samples, int stream)
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);
1114 last_stream_read = stream;
1115 atrk->current_position += samples;
1122 read_audio(double *output_d, int channel, long samples, int stream)
1124 return read_audio((void *)output_d, atyp_DOUBLE, channel, samples, stream);
1128 read_audio(float *output_f, int channel, long samples, int stream)
1130 return read_audio((void *)output_f, atyp_FLOAT, channel, samples, stream);
1134 read_audio(int *output_i, int channel, long samples, int stream)
1136 return read_audio((void *)output_i, atyp_INT, channel, samples, stream);
1140 read_audio(short *output_s, int channel, long samples, int stream)
1142 return read_audio((void *)output_s, atyp_SHORT, channel, samples, stream);
1146 reread_audio(void *output, int atyp, int channel, long samples, int stream)
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);
1155 last_stream_read = stream;
1156 atrk->current_position += samples;
1163 reread_audio(double *output_d, int channel, long samples, int stream)
1165 return reread_audio((void *)output_d, atyp_DOUBLE, channel, samples, stream);
1169 reread_audio(float *output_f, int channel, long samples, int stream)
1171 return reread_audio((void *)output_f, atyp_FLOAT, channel, samples, stream);
1175 reread_audio(int *output_i, int channel, long samples, int stream)
1177 return reread_audio((void *)output_i, atyp_INT, channel, samples, stream);
1181 reread_audio(short *output_s, int channel, long samples, int stream)
1183 return reread_audio((void *)output_s, atyp_SHORT, channel, samples, stream);
1188 read_audio_chunk(uint8_t *output, long *size, long max_size, int stream)
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);
1196 last_stream_read = stream;
1203 read_video_chunk( uint8_t *output, long *size, long max_size, int stream)
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);
1211 last_stream_read = stream;
1221 for( int i=0; i<total_vtracks; ++i )
1222 if( vtrack[i]->frame_cache )
1223 result += vtrack[i]->frame_cache->memory_usage();
1228 start_record(int fd, int bsz)
1230 if( recd_fd >= 0 ) return 1;
1232 memset(&st, 0, sizeof(st));
1233 if( fstat64(fd, &st) < 0 ) return 1;
1235 recd_pos = st.st_size;
1236 if (fs->start_record(bsz)) return recd_fd = -1;
1242 if( fs->stop_record() ) return 1;
1248 write_record(uint8_t *data, int len)
1250 if( recd_fd < 0 ) return;
1251 if( write(recd_fd, data, len) < 0 ) {
1252 zmsgs("write err: %s\n",strerror(errno));
1261 return fs->pause_reader(v);
1265 get_thumbnail(int trk, int64_t &frn, uint8_t *&t, int &w, int &h)
1268 if( trk>=0 && trk<total_vtracks ) {
1269 vtrack_t *vtrk = vtrack[trk];
1271 video_t *vid = vtrk->video;
1272 frn = vid->framenum;
1274 w = 2*vid->mb_width;
1275 h = 2*vid->mb_height;
1283 set_thumbnail_callback(int trk, int skim, int thumb,
1284 zthumbnail_cb fn, void *p)
1287 // all tracks, toc build
1290 // one track, commercials verify
1291 else if( trk >= 0 && trk<total_vtracks ) {
1292 vtrack_t *vtrk = vtrack[trk];
1294 video_t *vid = vtrk->video;
1295 if( !(result=vid->seek_video()) ) {
1311 set_cc_text_callback(int trk, zcc_text_cb fn)
1314 if( trk>=0 && trk<total_vtracks ) {
1315 vtrack_t *vtrk = vtrack[trk];
1317 video_t *vid = vtrk->video;
1318 vid->get_cc()->text_cb = fn;
1326 calculate_source_date(char *path)
1328 struct stat64 ostat;
1329 memset(&ostat,0,sizeof(struct stat64));
1330 return stat64(path, &ostat) < 0 ? 0 : ostat.st_mtime;
1334 calculate_source_date(int fd)
1336 struct stat64 ostat;
1337 memset(&ostat,0,sizeof(struct stat64));
1338 return fstat64(fd, &ostat) < 0 ? 0 : ostat.st_mtime;