|
6925
|
1 /*
|
|
|
2 raw dv file parser for MPlayer
|
|
|
3 by Alexander Neundorf <neundorf@kde.org>
|
|
|
4 based on the fli demuxer
|
|
|
5
|
|
|
6 LGPL
|
|
|
7 */
|
|
|
8
|
|
|
9 #include <stdio.h>
|
|
|
10 #include <stdlib.h>
|
|
|
11 #include <unistd.h>
|
|
|
12
|
|
|
13 #include "config.h"
|
|
|
14
|
|
|
15 #ifdef HAVE_LIBDV095
|
|
|
16
|
|
|
17 #include "mp_msg.h"
|
|
|
18 #include "help_mp.h"
|
|
|
19
|
|
|
20 #include "stream.h"
|
|
|
21 #include "demuxer.h"
|
|
|
22 #include "stheader.h"
|
|
|
23
|
|
|
24 #include <libdv/dv.h>
|
|
|
25 #include <libdv/dv_types.h>
|
|
|
26
|
|
|
27 #define DV_PAL_FRAME_SIZE 144000
|
|
|
28 #define DV_NTSC_FRAME_SIZE 122000
|
|
|
29
|
|
|
30 typedef struct
|
|
|
31 {
|
|
|
32 int current_frame;
|
|
|
33 int frame_size;
|
|
|
34 int current_filepos;
|
|
|
35 int frame_number;
|
|
|
36 dv_decoder_t *decoder;
|
|
|
37 } rawdv_frames_t;
|
|
|
38
|
|
|
39 void demux_seek_rawdv(demuxer_t *demuxer,float rel_seek_secs,int flags)
|
|
|
40 {
|
|
|
41 rawdv_frames_t *frames = (rawdv_frames_t *)demuxer->priv;
|
|
|
42 sh_video_t *sh_video = demuxer->video->sh;
|
|
|
43 int newpos=(flags&1)?0:frames->current_frame;
|
|
|
44 if(flags&2)
|
|
|
45 {
|
|
|
46 // float 0..1
|
|
|
47 newpos+=rel_seek_secs*frames->frame_number;
|
|
|
48 }
|
|
|
49 else
|
|
|
50 {
|
|
|
51 // secs
|
|
|
52 newpos+=rel_seek_secs*sh_video->fps;
|
|
|
53 }
|
|
|
54 if(newpos<0)
|
|
|
55 newpos=0;
|
|
|
56 else if(newpos>frames->frame_number)
|
|
|
57 newpos=frames->frame_number;
|
|
|
58 frames->current_frame=newpos;
|
|
|
59 frames->current_filepos=newpos*frames->frame_size;
|
|
|
60 }
|
|
|
61
|
|
7594
|
62 int rawdv_check_file(demuxer_t *demuxer)
|
|
6925
|
63 {
|
|
|
64 unsigned char tmp_buffer[DV_PAL_FRAME_SIZE];
|
|
|
65 int bytes_read=0;
|
|
|
66 int result=0;
|
|
|
67 dv_decoder_t *td;
|
|
7594
|
68
|
|
|
69 mp_msg(MSGT_DEMUX,MSGL_V,"Checking for DV\n");
|
|
|
70
|
|
6925
|
71 stream_reset(demuxer->stream);
|
|
|
72 stream_seek(demuxer->stream, 0);
|
|
|
73 bytes_read=stream_read(demuxer->stream,tmp_buffer,DV_PAL_FRAME_SIZE);
|
|
|
74 if ((bytes_read!=DV_PAL_FRAME_SIZE) && (bytes_read!=DV_NTSC_FRAME_SIZE))
|
|
|
75 return 0;
|
|
|
76
|
|
|
77 td=dv_decoder_new(TRUE,TRUE,FALSE);
|
|
|
78 td->quality=DV_QUALITY_BEST;
|
|
|
79 dv_parse_header(td, tmp_buffer);
|
|
|
80 if ((( td->num_dif_seqs==10) || (td->num_dif_seqs==12))
|
|
|
81 && (td->width==720)
|
|
|
82 && ((td->height==576) || (td->height==480)))
|
|
|
83 result=1;
|
|
|
84 dv_decoder_free(td);
|
|
|
85 return result;
|
|
|
86 }
|
|
|
87
|
|
|
88 // return value:
|
|
|
89 // 0 = EOF or no stream found
|
|
|
90 // 1 = successfully read a packet
|
|
|
91 int demux_rawdv_fill_buffer(demuxer_t *demuxer)
|
|
|
92 {
|
|
|
93 rawdv_frames_t *frames = (rawdv_frames_t *)demuxer->priv;
|
|
|
94 demux_packet_t* dp_video=NULL;
|
|
|
95 sh_video_t *sh_video = demuxer->video->sh;
|
|
|
96 int bytes_read=0;
|
|
|
97 // fprintf(stderr,"demux_rawdv_fill_buffer() seek to %d, size: %d\n",frames->current_filepos,frames->frame_size);
|
|
|
98 // fetch the frame from the file
|
|
|
99 // first, position the file properly since ds_read_packet() doesn't
|
|
|
100 // seem to do it, even though it takes a file offset as a parameter
|
|
|
101 stream_seek(demuxer->stream, frames->current_filepos);
|
|
|
102
|
|
|
103 dp_video=new_demux_packet(frames->frame_size);
|
|
|
104 bytes_read=stream_read(demuxer->stream,dp_video->buffer,frames->frame_size);
|
|
|
105 if (bytes_read<frames->frame_size)
|
|
|
106 return 0;
|
|
|
107 dp_video->pts=frames->current_frame/sh_video->fps;
|
|
|
108 dp_video->pos=frames->current_filepos;
|
|
|
109 dp_video->flags=0;
|
|
|
110
|
|
7673
|
111 if (demuxer->audio && demuxer->audio->id>=-1)
|
|
|
112 {
|
|
6925
|
113 demux_packet_t* dp_audio=clone_demux_packet(dp_video);
|
|
|
114 ds_add_packet(demuxer->audio,dp_audio);
|
|
|
115 }
|
|
|
116 ds_add_packet(demuxer->video,dp_video);
|
|
|
117 // get the next frame ready
|
|
|
118 frames->current_filepos+=frames->frame_size;
|
|
|
119 frames->current_frame++;
|
|
|
120 // fprintf(stderr," audio->packs: %d , video->packs: %d \n",demuxer->audio->packs, demuxer->video->packs);
|
|
|
121 return 1;
|
|
|
122 }
|
|
|
123
|
|
|
124 demuxer_t* demux_open_rawdv(demuxer_t* demuxer)
|
|
|
125 {
|
|
|
126 unsigned char dv_frame[DV_PAL_FRAME_SIZE];
|
|
|
127 sh_video_t *sh_video = NULL;
|
|
|
128 rawdv_frames_t *frames = (rawdv_frames_t *)malloc(sizeof(rawdv_frames_t));
|
|
|
129 dv_decoder_t *dv_decoder=NULL;
|
|
|
130
|
|
|
131 mp_msg(MSGT_DEMUXER,MSGL_V,"demux_open_rawdv() end_pos %d\n",demuxer->stream->end_pos);
|
|
|
132
|
|
|
133 // go back to the beginning
|
|
|
134 stream_reset(demuxer->stream);
|
|
|
135 stream_seek(demuxer->stream, 0);
|
|
|
136
|
|
|
137 //get the first frame
|
|
|
138 stream_read(demuxer->stream, dv_frame, DV_PAL_FRAME_SIZE);
|
|
|
139
|
|
|
140 //read params from this frame
|
|
|
141 dv_decoder=dv_decoder_new(TRUE,TRUE,FALSE);
|
|
|
142 dv_decoder->quality=DV_QUALITY_BEST;
|
|
|
143
|
|
|
144 dv_parse_header(dv_decoder, dv_frame);
|
|
|
145
|
|
|
146 // create a new video stream header
|
|
|
147 sh_video = new_sh_video(demuxer, 0);
|
|
|
148
|
|
|
149 // make sure the demuxer knows about the new video stream header
|
|
|
150 // (even though new_sh_video() ought to take care of it)
|
|
|
151 demuxer->seekable = 1;
|
|
|
152 demuxer->video->sh = sh_video;
|
|
|
153
|
|
|
154 // make sure that the video demuxer stream header knows about its
|
|
|
155 // parent video demuxer stream (this is getting wacky), or else
|
|
|
156 // video_read_properties() will choke
|
|
|
157 sh_video->ds = demuxer->video;
|
|
|
158
|
|
|
159 // custom fourcc for internal MPlayer use
|
|
|
160 // sh_video->format = mmioFOURCC('R', 'A', 'D', 'V');
|
|
|
161 sh_video->format = mmioFOURCC('D', 'V', 'S', 'D');
|
|
|
162
|
|
|
163 sh_video->disp_w = dv_decoder->width;
|
|
|
164 sh_video->disp_h = dv_decoder->height;
|
|
|
165 mp_msg(MSGT_DEMUXER,MSGL_V,"demux_open_rawdv() frame_size: %d w: %d h: %d dif_seq: %d system: %d\n",dv_decoder->frame_size,dv_decoder->width, dv_decoder->height,dv_decoder->num_dif_seqs,dv_decoder->system);
|
|
|
166
|
|
|
167 sh_video->fps= (dv_decoder->system==e_dv_system_525_60?29.97:25);
|
|
|
168 sh_video->frametime = 1.0/sh_video->fps;
|
|
|
169
|
|
|
170 // emulate BITMAPINFOHEADER for win32 decoders:
|
|
|
171 sh_video->bih=malloc(sizeof(BITMAPINFOHEADER));
|
|
|
172 memset(sh_video->bih,0,sizeof(BITMAPINFOHEADER));
|
|
|
173 sh_video->bih->biSize=40;
|
|
|
174 sh_video->bih->biWidth = dv_decoder->width;
|
|
|
175 sh_video->bih->biHeight = dv_decoder->height;
|
|
|
176 sh_video->bih->biPlanes=1;
|
|
|
177 sh_video->bih->biBitCount=24;
|
|
|
178 sh_video->bih->biCompression=sh_video->format; // "DVSD"
|
|
|
179 sh_video->bih->biSizeImage=sh_video->bih->biWidth*sh_video->bih->biHeight*3;
|
|
|
180
|
|
|
181
|
|
|
182 frames->current_filepos=0;
|
|
|
183 frames->current_frame=0;
|
|
|
184 frames->frame_size=dv_decoder->frame_size;
|
|
|
185 frames->frame_number=demuxer->stream->end_pos/frames->frame_size;
|
|
|
186
|
|
|
187 mp_msg(MSGT_DEMUXER,MSGL_V,"demux_open_rawdv() seek to %d, size: %d, dv_dec->frame_size: %d\n",frames->current_filepos,frames->frame_size, dv_decoder->frame_size);
|
|
7673
|
188 if (dv_decoder->audio != NULL && demuxer->audio->id>=-1){
|
|
6925
|
189 sh_audio_t *sh_audio = new_sh_audio(demuxer, 0);
|
|
|
190 demuxer->audio->sh = sh_audio;
|
|
|
191 sh_audio->ds = demuxer->audio;
|
|
|
192 mp_msg(MSGT_DEMUXER,MSGL_V,"demux_open_rawdv() chan: %d samplerate: %d\n",dv_decoder->audio->num_channels,dv_decoder->audio->frequency );
|
|
|
193 // custom fourcc for internal MPlayer use
|
|
|
194 sh_audio->format = mmioFOURCC('R', 'A', 'D', 'V');
|
|
|
195
|
|
|
196 sh_audio->wf = malloc(sizeof(WAVEFORMATEX));
|
|
|
197 memset(sh_audio->wf, 0, sizeof(WAVEFORMATEX));
|
|
|
198 sh_audio->wf->wFormatTag = sh_audio->format;
|
|
|
199 sh_audio->wf->nChannels = dv_decoder->audio->num_channels;
|
|
|
200 sh_audio->wf->wBitsPerSample = 16;
|
|
|
201 sh_audio->wf->nSamplesPerSec = dv_decoder->audio->frequency;
|
|
|
202 // info about the input stream:
|
|
|
203 sh_audio->wf->nAvgBytesPerSec = sh_video->fps*dv_decoder->frame_size;
|
|
|
204 sh_audio->wf->nBlockAlign = dv_decoder->frame_size;
|
|
|
205
|
|
|
206 // sh_audio->context=(void*)dv_decoder;
|
|
|
207 }
|
|
|
208 stream_reset(demuxer->stream);
|
|
|
209 stream_seek(demuxer->stream, 0);
|
|
|
210 dv_decoder_free(dv_decoder); //we keep this in the context of both stream headers
|
|
|
211 demuxer->priv=frames;
|
|
|
212 return demuxer;
|
|
|
213 }
|
|
|
214
|
|
|
215 void demux_close_rawdv(demuxer_t* demuxer)
|
|
|
216 {
|
|
|
217 rawdv_frames_t *frames = (rawdv_frames_t *)demuxer->priv;
|
|
|
218
|
|
|
219 if(frames==0)
|
|
|
220 return;
|
|
|
221 free(frames);
|
|
|
222 }
|
|
|
223
|
|
|
224 #endif
|
