--- /dev/null
+#include "../libzmpeg3.h"
+
+/* zig-zag scan */
+uint8_t zvideo_t::
+zig_zag_scan_nommx[64] = {
+ 0 , 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5,
+ 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28,
+ 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
+ 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63,
+};
+
+/* alternate scan */
+uint8_t zvideo_t::
+alternate_scan_nommx[64] = {
+ 0, 8, 16, 24, 1, 9, 2, 10, 17, 25, 32, 40, 48, 56, 57, 49,
+ 41, 33, 26, 18, 3, 11, 4, 12, 19, 27, 34, 42, 50, 58, 35, 43,
+ 51, 59, 20, 28, 5, 13, 6, 14, 21, 29, 36, 44, 52, 60, 37, 45,
+ 53, 61, 22, 30, 7, 15, 23, 31, 38, 46, 54, 62, 39, 47, 55, 63,
+};
+
+/* default intra quantization matrix */
+uint8_t zvideo_t::
+default_intra_quantizer_matrix[64] = {
+ 8, 16, 19, 22, 26, 27, 29, 34,
+ 16, 16, 22, 24, 27, 29, 34, 37,
+ 19, 22, 26, 27, 29, 34, 34, 38,
+ 22, 22, 26, 27, 29, 34, 37, 40,
+ 22, 26, 27, 29, 32, 35, 40, 48,
+ 26, 27, 29, 32, 35, 40, 48, 58,
+ 26, 27, 29, 34, 38, 46, 56, 69,
+ 27, 29, 35, 38, 46, 56, 69, 83,
+};
+
+double zvideo_t::
+frame_rate_table[16] = {
+ 0.0, /* Pad */
+ (double)24000.0/1001.0, /* Official frame rates */
+ (double)24.0,
+ (double)25.0,
+ (double)30000.0/1001.0,
+ (double)30.0,
+ (double)50.0,
+ (double)60000.0/1001.0,
+ (double)60.0,
+
+ 1.0, 5.0, 10.0, 12.0, 15.0, /* Unofficial economy rates */
+ 0.0, 0.0,
+};
+
+static int blk_cnt_tab[3] = { 6, 8, 12 };
+
+int zvideo_t::
+init_decoder()
+{
+ int i, j, sz, cc;
+ long size[4], padding[2]; /* Size of Y, U, and V buffers */
+
+ if( !mpeg2 ) { /* force MPEG-1 parameters */
+ prog_seq = 1;
+ prog_frame = 1;
+ pict_struct = pics_FRAME_PICTURE;
+ frame_pred_dct = 1;
+ chroma_format = cfmt_420;
+ matrix_coefficients = 5;
+ }
+
+/* Get dimensions rounded to nearest multiple of coded macroblocks */
+ mb_width = (horizontal_size + 15) / 16;
+ mb_height = (mpeg2 && !prog_seq) ?
+ (2 * ((vertical_size + 31) / 32)) : ((vertical_size + 15) / 16);
+ coded_picture_width = 16 * mb_width;
+ coded_picture_height = 16 * mb_height;
+ chrom_width = (chroma_format == cfmt_444) ?
+ coded_picture_width : (coded_picture_width >> 1);
+ chrom_height = (chroma_format != cfmt_420) ?
+ coded_picture_height : (coded_picture_height >> 1);
+ blk_cnt = blk_cnt_tab[chroma_format - 1];
+
+/* Get sizes of YUV buffers */
+ padding[0] = 16*coded_picture_width + 16;
+ size[0] = coded_picture_width*coded_picture_height + padding[0];
+
+ padding[1] = 16*chrom_width + 16;
+ size[1] = chrom_width*chrom_height + padding[1];
+ size[3] = (size[2] = (llw * llh)) / 4;
+
+/* Allocate contiguous fragments for YUV buffers for hardware YUV decoding */
+ sz = size[0] + 2*size[1];
+ yuv_buffer[0] = new uint8_t[sz]; memset(yuv_buffer[0],0,sz);
+ yuv_buffer[1] = new uint8_t[sz]; memset(yuv_buffer[1],0,sz);
+ yuv_buffer[2] = new uint8_t[sz]; memset(yuv_buffer[2],0,sz);
+
+ if( scalable_mode == slice_decoder_t::sc_SPAT ) {
+ sz = size[2] + 2 * size[3];
+ yuv_buffer[3] = new uint8_t[sz]; memset(yuv_buffer[3],0,sz);
+ yuv_buffer[4] = new uint8_t[sz]; memset(yuv_buffer[4],0,sz);
+ }
+
+ tdat = new uint8_t[4 * mb_width * mb_height];
+ memset(tdat, 0, 4 * mb_width * mb_height);
+
+ slice_decoder_t::init_tables();
+
+/* Direct pointers to areas of contiguous fragments in YVU order per Microsoft */
+ for( cc=0; cc<3; ++cc ) {
+ llframe0[cc] = 0;
+ llframe1[cc] = 0;
+ newframe[cc] = 0;
+ }
+
+ refframe[0] = yuv_buffer[0];
+ oldrefframe[0] = yuv_buffer[1];
+ auxframe[0] = yuv_buffer[2];
+ sz = size[0];
+ refframe[2] = yuv_buffer[0] + sz;
+ oldrefframe[2] = yuv_buffer[1] + sz;
+ auxframe[2] = yuv_buffer[2] + sz;
+ sz += size[1];
+ refframe[1] = yuv_buffer[0] + sz;
+ oldrefframe[1] = yuv_buffer[1] + sz;
+ auxframe[1] = yuv_buffer[2] + sz;
+
+ if( scalable_mode == slice_decoder_t::sc_SPAT ) {
+/* this assumes lower layer is 4:2:0 */
+ sz = padding[0];
+ llframe0[0] = yuv_buffer[3] + sz;
+ llframe1[0] = yuv_buffer[4] + sz;
+ sz = padding[1] + size[2];
+ llframe0[2] = yuv_buffer[3] + sz;
+ llframe1[2] = yuv_buffer[4] + sz;
+ sz += size[3];
+ llframe0[1] = yuv_buffer[3] + sz;
+ llframe1[1] = yuv_buffer[4] + sz;
+ }
+
+/* Initialize the YUV tables for software YUV decoding */
+ cr_to_r = new int[256];
+ crb_to_g = new int[256*256];
+ cb_to_b = new int[256];
+ int *cr_to_r_ptr = cr_to_r + 128;
+ int *crb_to_g_ptr = crb_to_g + 128*256 + 128;
+ int *cb_to_b_ptr = cb_to_b + 128;
+
+ for( i=-128; i<128; ++i ) {
+ cr_to_r_ptr[i] = (int)(1.371*i * 65536.);
+ for( j=-128; j<128; ++j )
+ crb_to_g_ptr[i*256 + j] = (int)((-0.698*i + -0.336*j) * 65536.);
+ cb_to_b_ptr[i] = (int)((1.732*i) * 65536.);
+ }
+
+ decoder_initted = 1;
+ return 0;
+}
+
+int zvideo_t::
+delete_decoder()
+{
+ if( yuv_buffer[0] ) delete [] yuv_buffer[0];
+ if( yuv_buffer[1] ) delete [] yuv_buffer[1];
+ if( yuv_buffer[2] ) delete [] yuv_buffer[2];
+
+ if( subtitle_frame[0] ) delete [] subtitle_frame[0];
+ if( subtitle_frame[1] ) delete [] subtitle_frame[1];
+ if( subtitle_frame[2] ) delete [] subtitle_frame[2];
+
+ if( llframe0[0] ) {
+ delete [] yuv_buffer[3];
+ delete [] yuv_buffer[4];
+ }
+ delete [] tdat;
+
+ delete [] cr_to_r;
+ delete [] crb_to_g;
+ delete [] cb_to_b;
+ return 0;
+}
+
+void zvideo_t::
+init_scantables()
+{
+ zigzag_scan_table = zig_zag_scan_nommx;
+ alternate_scan_table = alternate_scan_nommx;
+}
+
+void zvideo_t::
+init_video()
+{
+ int result;
+ init_decoder();
+ track->width = horizontal_size;
+ track->height = vertical_size;
+ track->frame_rate = frame_rate;
+ demuxer_t *demux = vstream->demuxer;
+
+ /* Try to get the length of the file from GOP's */
+ if( !track->frame_offsets ) {
+ if( src->is_video_stream() ) {
+ /* Load the first GOP */
+ rewind_video(0);
+ result = vstream->next_code(GOP_START_CODE);
+ if( !result ) vstream->get_bits(32);
+ if( !result ) result = get_gop_header();
+ first_frame = gop_to_frame(&gop_timecode);
+ /* GOPs are supposed to have 16 frames */
+ frames_per_gop = 16;
+ /* Read the last GOP in the file by seeking backward. */
+ demux->seek_byte(demux->movie_size());
+ demux->start_reverse();
+ result = demux->prev_code(GOP_START_CODE);
+ demux->start_forward();
+ vstream->reset();
+ vstream->get_bits(8);
+ if(!result) result = get_gop_header();
+ last_frame = gop_to_frame(&gop_timecode);
+//zmsgs("3 %p\n", this);
+ /* Count number of frames to end */
+ while( !result ) {
+ result = vstream->next_code(PICTURE_START_CODE);
+ if( !result ) {
+ vstream->get_byte_noptr();
+ ++last_frame;
+ }
+ }
+
+ track->total_frames = last_frame-first_frame+1;
+//zmsgs("mpeg3video_new 3 %ld\n", track->total_frames);
+ }
+ else {
+ /* Try to get the length of the file from the multiplexing. */
+ /* Need a table of contents */
+/* first_frame = 0;
+ * track->total_frames = last_frame =
+ * (long)(demux->length() * frame_rate);
+ * first_frame = 0;
+ */
+ }
+ }
+ else {
+ /* Get length from table of contents */
+ track->total_frames = track->total_frame_offsets-1;
+ }
+
+ maxframe = track->total_frames;
+ rewind_video(0);
+}
+
+int zvideo_t::
+video_pts_padding()
+{
+ int result = 0;
+ if( track->video_time >= 0 && src->pts_padding > 0 ) {
+ int pts_framenum = track->video_time*track->frame_rate + 0.5;
+ int padding = pts_framenum - track->pts_position;
+ if( padding > 0 ) {
+ if( track->vskip <= 0 ) {
+ int limit = 3;
+ if( padding > limit ) {
+ zmsgs("video start padding pid %02x @ %12d (%12.6f) %d\n",
+ track->pid, framenum, track->get_video_time(), padding);
+ track->vskip = 1;
+ result = 1;
+ }
+ }
+ else if( !(++track->vskip & 1) || padding > track->frame_rate )
+ result = 1;
+ if( result ) ++track->pts_position;
+ }
+ else if( track->vskip > 0 ) {
+ zmsgs("video end padding pid %02x @ %12d (%12.6f) %d\n",
+ track->pid, framenum, track->get_video_time(), (1+track->vskip)/2);
+ track->vskip = 0;
+ }
+ }
+ return result;
+}
+
+int zvideo_t::
+video_pts_skipping()
+{
+ int result = 0;
+ if( track->video_time >= 0 && src->pts_padding > 0 ) {
+ int pts_framenum = track->video_time*track->frame_rate + 0.5;
+ int skipping = track->pts_position - pts_framenum;
+ if( skipping > 0 ) {
+ if( track->vskip >= 0 ) {
+ int limit = 3;
+ if( skipping > limit ) {
+ zmsgs("video start skipping pid %02x @ %12d (%12.6f) %d frames\n",
+ track->pid, framenum, track->get_video_time(), skipping);
+ track->vskip = -1;
+ result = 1;
+ }
+ }
+ else if( !(--track->vskip & 1) || skipping > track->frame_rate )
+ result = 1;
+ if( result ) --track->pts_position;
+ }
+ else if( track->vskip < 0 ) {
+ zmsgs("video end skipping pid %02x @ %12d (%12.6f) %d frames\n",
+ track->pid, framenum, track->get_video_time(), (1-track->vskip)/2);
+ track->vskip = 0;
+ }
+ }
+ return result;
+}
+
+int zvideo_t::
+eof()
+{
+ while( vstream->eof() ) {
+ demuxer_t *demux = vstream->demuxer;
+ if( demux->seek_phys() ) return 1;
+ }
+ return 0;
+}
+
+
+/* The way they do field based encoding, */
+/* the I frames have the top field but both the I frame and */
+/* subsequent P frame are interlaced to make the keyframe. */
+
+int zvideo_t::
+read_picture()
+{
+ int result = 0;
+ int field = 0;
+ got_top = got_bottom = 0;
+ secondfield = 0;
+
+ do {
+ if( (result=eof()) != 0 ) break;
+ if( (result=get_header()) != 0 ) break;
+ if( pict_struct != pics_FRAME_PICTURE ) secondfield = field;
+ /* if dropping frames then skip B frames, */
+ /* Don't skip the B frames which generate original */
+ /* repeated frames at the end of the skip sequence */
+ if( !skip_bframes || pict_type != pic_type_B ||
+ repeat_fields > 2*skip_bframes ) {
+ if( (result=get_picture()) != 0 ) break;
+ }
+ ++field;
+ if( pict_struct == pics_FRAME_PICTURE ) { got_top = got_bottom = field; break; }
+ if( pict_struct == pics_TOP_FIELD ) got_top = field;
+ else if( pict_struct == pics_BOTTOM_FIELD ) got_bottom = field;
+ } while( !secondfield );
+
+ if( pict_type != pic_type_B )
+ ++ref_frames;
+
+ return result;
+}
+
+int zvideo_t::
+read_frame_backend(int zskip_bframes)
+{
+ int result = 0;
+//if( src->seekable ) {
+// int app_pos = track->apparent_position();
+// double vtime = track->get_video_time();
+// int pts_frm = vtime * track->frame_rate + 0.5;
+// zmsgs(" apr_pos %f: %d/%d + %d: pts_frame %d + %d\n", vtime,
+// app_pos, framenum, app_pos - framenum, pts_frm, pts_frm-framenum);
+//}
+ if( !mpeg2 ) current_field = repeat_fields = 0;
+
+ /* Repeat if current_field is more than 1 field from repeat_fields */
+ if( !repeat_fields || current_field+2 >= repeat_fields ) {
+ if( (repeat_fields -= current_field) < 0 ) repeat_fields = 0;
+ track->update_video_time();
+
+ // if pts lags framenum, skip to next picture
+ // only skip once (double speed) to catch up
+ while( !(result=find_header()) ) {
+ if( !video_pts_skipping() ) break;
+ vstream->refill();
+ }
+
+ // if framenum lags pts, repeat picture
+ if( !result && !video_pts_padding() ) {
+ track->update_frame_pts();
+ skip_bframes = zskip_bframes;
+//static const char *pstruct[] = { "nil", "top", "bot", "fld" };
+//zmsgs("video %d PID %02x frame %d vtime %12.5f %c/%s %d 0x%010lx/0x%010lx %d/%d\n",
+// result, track->pid, framenum, track->get_video_time(), "XIPBD"[pict_type],
+// pstruct[pict_struct], skip_bframes, vstream->demuxer->last_packet_start,
+// vstream->demuxer->absolute_position()-vstream->demuxer->zdata.length(),
+// repeat_fields, current_field);
+ result = read_picture();
+#if 0
+{ char fn[512];
+ snprintf(&fn[0],sizeof(fn),"/tmp/dat/f%05d.pnm",framenum);
+ int fd = open(&fn[0],O_CREAT+O_TRUNC+O_WRONLY,0666);
+ write(fd,&fn, snprintf(&fn[0],sizeof(fn),
+ "P5\n%d %d\n255\n", coded_picture_width, coded_picture_height));
+ write(fd,output_src[0],coded_picture_width*coded_picture_height);
+ close(fd);
+}
+#endif
+ }
+ }
+
+ if( !result ) {
+ if( mpeg2 ) current_field = !repeat_fields ? 0 : current_field+2;
+ decode_subtitle();
+ last_number = framenum++;
+ }
+
+ return result;
+}
+
+int* zvideo_t::
+get_scaletable(int in_l, int out_l)
+{
+ int *result = new int[out_l];
+ double scale = (double)in_l / out_l;
+ for( int i=0; i<out_l; ++i ) {
+ result[i] = (int)(scale * i);
+ }
+ return result;
+}
+
+long zvideo_t::
+gop_to_frame(timecode_t *gop_timecode)
+{
+/* Mirror of what mpeg2enc does */
+ int fps = (int)(frame_rate + 0.5);
+ int hour = gop_timecode->hour;
+ int minute = gop_timecode->minute;
+ int second = gop_timecode->second;
+ int frame = gop_timecode->frame;
+ long result = ((long)hour*3600 + minute*60 + second)*fps + frame;
+ return result;
+}
+
+
+/* ======================================================================= */
+/* ENTRY POINTS */
+/* ======================================================================= */
+
+
+
+zvideo_t::
+video_t(zmpeg3_t *zsrc, zvtrack_t *ztrack)
+{
+ src = zsrc;
+ track = ztrack;
+ vstream = new bits_t(zsrc, track->demuxer);
+//zmsgs("%d\n", vstream->eof());
+ last_number = -1;
+/* First frame is all green */
+ framenum = -1;
+ byte_seek = -1;
+ frame_seek = -1;
+ subtitle_track = -1;
+
+ init_scantables();
+ init_output();
+ allocate_slice_buffers();
+ slice_wait.lock();
+}
+
+zvideo_t *zmpeg3_t::
+new_video_t(zvtrack_t *ztrack)
+{
+ int result = 0;
+ video_t *new_video = new video_t(this,ztrack);
+
+/* Get encoding parameters from stream */
+ if( seekable ) {
+ result = new_video->get_header();
+ if( !result )
+ new_video->init_video();
+ else {
+/* No header found */
+#ifdef TODO
+ zerr("no header found.\n");
+ delete new_video;
+ new_video = 0;
+#endif
+ }
+ }
+
+ return new_video;
+}
+
+zvideo_t::
+~video_t()
+{
+ delete_slice_buffers();
+ if( decoder_initted )
+ delete_decoder();
+ delete vstream;
+ delete cc;
+ if( x_table ) {
+ delete [] x_table;
+ delete [] y_table;
+ }
+}
+
+int zvideo_t::
+set_cpus(int cpus)
+{
+ return 0;
+}
+
+int zvideo_t::
+set_mmx(int use_mmx)
+{
+ init_scantables();
+ return 0;
+}
+
+/* Read all the way up to and including the next picture start code */
+int zvideo_t::
+read_raw(uint8_t *output, long *size, long max_size)
+{
+ uint32_t zcode = 0;
+ long sz = 0;
+ while( zcode!=PICTURE_START_CODE && zcode!=SEQUENCE_END_CODE &&
+ sz < max_size && !eof() ) {
+ uint8_t byte = vstream->get_byte_noptr();
+ *output++ = byte;
+ zcode = (zcode << 8) | byte;
+ ++sz;
+ }
+ *size = sz;
+ return eof();
+}
+
+int zvideo_t::read_frame( uint8_t **output_rows,
+ int in_x, int in_y, int in_w, int in_h,
+ int out_w, int out_h, int color_model)
+{
+ uint8_t *y, *u, *v;
+ int frame_number, result;
+ result = 0;
+ want_yvu = 0;
+ this->output_rows = output_rows;
+ this->color_model = color_model;
+
+/* Get scaling tables */
+ if( this->out_w != out_w || this->out_h != out_h ||
+ this->in_w != in_w || this->in_h != in_h ||
+ this->in_x != in_x || this->in_y != in_y) {
+ if(x_table) {
+ delete [] x_table; x_table = 0;
+ delete [] y_table; y_table = 0;
+ }
+ }
+
+ this->out_w = out_w; this->out_h = out_h;
+ this->in_w = in_w; this->in_h = in_h;
+ this->in_x = in_x; this->in_y = in_y;
+
+ if( !x_table ) {
+ x_table = get_scaletable(in_w, out_w);
+ y_table = get_scaletable(in_h, out_h);
+ }
+//zmsgs("mpeg3video_read_frame 1 %d\n", framenum);
+
+/* Recover from cache */
+ frame_number = frame_seek >= 0 ? frame_seek : framenum;
+ cache_t *cache = track->frame_cache;
+ if( frame_seek != last_number &&
+ cache->get_frame(frame_number, &y, &u, &v) ) {
+//zmsgs("1 %d\n", frame_number);
+ /* Transfer with cropping */
+ if( y ) present_frame(y, u, v);
+ /* Advance either framenum or frame_seek */
+ if( frame_number == framenum )
+ framenum = ++frame_number;
+ else if( frame_number == frame_seek )
+ frame_seek = ++frame_number;
+ }
+ else {
+ /* Only decode if it's a different frame */
+ if( frame_seek < 0 || last_number < 0 ||
+ frame_seek != last_number) {
+ if( !result ) result = seek();
+ if( !result ) result = read_frame_backend(0);
+ }
+ else {
+ framenum = frame_seek + 1;
+ last_number = frame_seek;
+ frame_seek = -1;
+ }
+ if( output_src[0] )
+ present_frame(output_src[0], output_src[1], output_src[2]);
+ }
+ return result;
+}
+
+int zvideo_t::
+read_yuvframe(char *y_output, char *u_output, char *v_output,
+ int in_x, int in_y, int in_w, int in_h)
+{
+ uint8_t *y = 0, *u = 0, *v = 0;
+ int result = 0;
+//zmsgs("1 %d\n", framenum);
+ want_yvu = 1;
+ this->y_output = y_output;
+ this->u_output = u_output;
+ this->v_output = v_output;
+ this->in_x = in_x;
+ this->in_y = in_y;
+ this->in_w = in_w;
+ this->in_h = in_h;
+
+ /* Recover from cache if framenum exists */
+ int frame_number = frame_seek >= 0 ? frame_seek : framenum;
+ cache_t *cache = track->frame_cache;
+ if( cache->get_frame(frame_number, &y, &u, &v) ) {
+//zmsgs("1 %d\n", frame_number);
+ /* Transfer with cropping */
+ if( y ) present_frame(y, u, v);
+ /* Advance either framenum or frame_seek */
+ if( frame_number == framenum )
+ framenum = ++frame_number;
+ else if( frame_number == frame_seek )
+ frame_seek = ++frame_number;
+ }
+ else {
+ if( !result ) result = seek();
+ if( !result ) result = read_frame_backend(0);
+ if( !result && output_src[0] )
+ present_frame(output_src[0], output_src[1], output_src[2]);
+ }
+
+ want_yvu = 0;
+ byte_seek = -1;
+ return result;
+}
+
+int zvideo_t::
+read_yuvframe_ptr(char **y_output, char **u_output, char **v_output)
+{
+ uint8_t *y, *u, *v;
+ int frame_number, result;
+ int debug = 0;
+ result = 0;
+ want_yvu = 1;
+ *y_output = *u_output = *v_output = 0;
+
+ frame_number = frame_seek >= 0 ? frame_seek : framenum;
+ cache_t *cache = track->frame_cache;
+ if( debug ) zmsgs("%d\n", __LINE__);
+ if( cache->get_frame(frame_number, &y, &u, &v) ) {
+ if( debug ) zmsgs("%d\n", __LINE__);
+ *y_output = (char*)y;
+ *u_output = (char*)u;
+ *v_output = (char*)v;
+ /* Advance either framenum or frame_seek */
+ if( frame_number == framenum )
+ framenum = ++frame_number;
+ else if( frame_number == frame_seek )
+ frame_seek = ++frame_number;
+ if( debug ) zmsgs("%d\n", __LINE__);
+ }
+ /* Only decode if it's a different frame */
+ else if( frame_seek < 0 || last_number < 0 ||
+ frame_seek != last_number) {
+ if( debug ) zmsgs("%d\n", __LINE__);
+ if( !result ) result = seek();
+ if( debug ) zmsgs("%d\n", __LINE__);
+ if( !result ) result = read_frame_backend(0);
+ if( debug ) zmsgs("%d\n", __LINE__);
+
+ if( output_src[0] ) {
+ *y_output = (char*)output_src[0];
+ *u_output = (char*)output_src[1];
+ *v_output = (char*)output_src[2];
+ }
+ if( debug ) zmsgs("%d\n", __LINE__);
+ }
+ else {
+ if( debug ) zmsgs("%d\n", __LINE__);
+ framenum = frame_seek + 1;
+ last_number = frame_seek;
+ frame_seek = -1;
+
+ if( output_src[0 ]) {
+ *y_output = (char*)output_src[0];
+ *u_output = (char*)output_src[1];
+ *v_output = (char*)output_src[2];
+ }
+ if( debug ) zmsgs("%d\n", __LINE__);
+ }
+
+ if( debug ) zmsgs("%d\n", __LINE__);
+ want_yvu = 0;
+/* Caching not used if byte seek */
+ byte_seek = -1;
+ return result;
+}
+
+int zvideo_t::
+colormodel()
+{
+ switch( chroma_format ) {
+ case cfmt_422: return cmdl_YUV422P; break;
+ case cfmt_420: return cmdl_YUV420P; break;
+ }
+ return cmdl_YUV420P;
+}
+
+zcc_t *zvideo_t::
+get_cc()
+{
+ if( !cc )
+ cc = new cc_t(this);
+ return cc;
+}
+
+void zvideo_t::
+reset_subtitles()
+{
+ for( int i=0; i<src->total_stracks; ++i ) {
+ strack_t *strack = src->strack[i];
+ if( strack->video != this ) continue;
+ strack->del_all_subtitles();
+ }
+}
+
+int zvideo_t::
+show_subtitle(int strk)
+{
+ int ret = subtitle_track;
+ if( subtitle_track != strk ) {
+ reset_subtitles();
+ subtitle_track = strk;
+ if( cc ) {
+ if( strk >= 0 ) cc->reset();
+ else { delete cc; cc = 0; }
+ }
+ }
+ return ret;
+}
+
+void zvideo_t::
+dump()
+{
+ zmsg("\n");
+ zmsg(" *** sequence extension 1\n");
+ zmsgs("prog_seq=%d\n", prog_seq);
+ zmsg(" *** picture header 1\n");
+ zmsgs("pict_type=%d field_sequence=%d\n", pict_type, field_sequence);
+ zmsg(" *** picture coding extension 1\n");
+ zmsgs("field_sequence=%d repeatfirst=%d prog_frame=%d pict_struct=%d\n",
+ field_sequence, repeatfirst, prog_frame, pict_struct);
+}
+
projects / goodguy / history.git / blobdiff