1 /*
2 * raw DV file parser
3 * copyright (c) 2002 Alexander Neundorf <neundorf@kde.org>
4 * based on the fli demuxer
5 *
6 * This file is part of MPlayer.
7 *
8 * MPlayer is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * MPlayer is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with MPlayer; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <unistd.h>
26
27 #include "config.h"
28
29 #include "mp_msg.h"
30 #include "help_mp.h"
31
32 #include "stream/stream.h"
33 #include "demuxer.h"
34 #include "stheader.h"
35
36 #include <libdv/dv.h>
37 #include <libdv/dv_types.h>
38
39 #define DV_PAL_FRAME_SIZE 144000
40 #define DV_NTSC_FRAME_SIZE 122000
41
42 typedef struct
43 {
44 int current_frame;
45 int frame_size;
46 off_t current_filepos;
47 int frame_number;
48 dv_decoder_t *decoder;
49 } rawdv_frames_t;
50
demux_seek_rawdv(demuxer_t * demuxer,float rel_seek_secs,float audio_delay,int flags)51 static void demux_seek_rawdv(demuxer_t *demuxer,float rel_seek_secs,float audio_delay,int flags)
52 {
53 rawdv_frames_t *frames = demuxer->priv;
54 sh_video_t *sh_video = demuxer->video->sh;
55 off_t newpos=(flags&SEEK_ABSOLUTE)?0:frames->current_frame;
56 if(flags&SEEK_FACTOR)
57 {
58 // float 0..1
59 newpos+=rel_seek_secs*frames->frame_number;
60 }
61 else
62 {
63 // secs
64 newpos+=rel_seek_secs*sh_video->fps;
65 }
66 if(newpos<0)
67 newpos=0;
68 else if(newpos>frames->frame_number)
69 newpos=frames->frame_number;
70 frames->current_frame=newpos;
71 frames->current_filepos=newpos*frames->frame_size;
72 }
73
rawdv_check_file(demuxer_t * demuxer)74 static int rawdv_check_file(demuxer_t *demuxer)
75 {
76 unsigned char tmp_buffer[DV_PAL_FRAME_SIZE];
77 int bytes_read=0;
78 int result=0;
79 dv_decoder_t *td;
80
81 mp_msg(MSGT_DEMUX,MSGL_V,"Checking for DV\n");
82
83 bytes_read=stream_read(demuxer->stream,tmp_buffer,DV_PAL_FRAME_SIZE);
84 if ((bytes_read!=DV_PAL_FRAME_SIZE) && (bytes_read!=DV_NTSC_FRAME_SIZE))
85 return 0;
86
87 td=dv_decoder_new(TRUE,TRUE,FALSE);
88 if (!td)
89 return 0;
90
91 td->quality=DV_QUALITY_BEST;
92 result=dv_parse_header(td, tmp_buffer);
93 if (result<0)
94 return 0;
95
96 if ((( td->num_dif_seqs==10) || (td->num_dif_seqs==12))
97 && (td->width==720)
98 && ((td->height==576) || (td->height==480)))
99 result=1;
100 dv_decoder_free(td);
101 return result ? DEMUXER_TYPE_RAWDV : 0;
102 }
103
104 // return value:
105 // 0 = EOF or no stream found
106 // 1 = successfully read a packet
demux_rawdv_fill_buffer(demuxer_t * demuxer,demux_stream_t * ds)107 static int demux_rawdv_fill_buffer(demuxer_t *demuxer, demux_stream_t *ds)
108 {
109 rawdv_frames_t *frames = demuxer->priv;
110 demux_packet_t* dp_video=NULL;
111 sh_video_t *sh_video = demuxer->video->sh;
112 int bytes_read=0;
113 // fprintf(stderr,"demux_rawdv_fill_buffer() seek to %llu, size: %d\n",frames->current_filepos,frames->frame_size);
114 // fetch the frame from the file
115 // first, position the file properly since ds_read_packet() doesn't
116 // seem to do it, even though it takes a file offset as a parameter
117 stream_seek(demuxer->stream, frames->current_filepos);
118
119 dp_video=new_demux_packet(frames->frame_size);
120 bytes_read=stream_read(demuxer->stream,dp_video->buffer,frames->frame_size);
121 if (bytes_read<frames->frame_size) {
122 free_demux_packet(dp_video);
123 return 0;
124 }
125 dp_video->pts=frames->current_frame/sh_video->fps;
126 dp_video->pos=frames->current_filepos;
127 dp_video->flags=0;
128
129 if (demuxer->audio && demuxer->audio->id>=-1)
130 {
131 demux_packet_t* dp_audio=clone_demux_packet(dp_video);
132 ds_add_packet(demuxer->audio,dp_audio);
133 }
134 ds_add_packet(demuxer->video,dp_video);
135 // get the next frame ready
136 frames->current_filepos+=frames->frame_size;
137 frames->current_frame++;
138 // fprintf(stderr," audio->packs: %d , video->packs: %d \n",demuxer->audio->packs, demuxer->video->packs);
139 return 1;
140 }
141
demux_open_rawdv(demuxer_t * demuxer)142 static demuxer_t* demux_open_rawdv(demuxer_t* demuxer)
143 {
144 unsigned char dv_frame[DV_PAL_FRAME_SIZE];
145 sh_video_t *sh_video = NULL;
146 rawdv_frames_t *frames = calloc(1, sizeof(*frames));
147 dv_decoder_t *dv_decoder=NULL;
148
149 mp_msg(MSGT_DEMUXER,MSGL_V,"demux_open_rawdv() end_pos %"PRId64"\n",(int64_t)demuxer->stream->end_pos);
150
151 // go back to the beginning
152 stream_reset(demuxer->stream);
153 stream_seek(demuxer->stream, 0);
154
155 //get the first frame
156 stream_read(demuxer->stream, dv_frame, DV_PAL_FRAME_SIZE);
157
158 //read params from this frame
159 dv_decoder=dv_decoder_new(TRUE,TRUE,FALSE);
160 if (!dv_decoder)
161 goto err_out;
162 dv_decoder->quality=DV_QUALITY_BEST;
163
164 if (dv_parse_header(dv_decoder, dv_frame) == -1)
165 goto err_out;
166
167 // create a new video stream header
168 sh_video = new_sh_video(demuxer, 0);
169 if (!sh_video)
170 goto err_out;
171
172 // make sure the demuxer knows about the new video stream header
173 // (even though new_sh_video() ought to take care of it)
174 demuxer->seekable = 1;
175 demuxer->video->id = 0;
176 demuxer->video->sh = sh_video;
177
178 // custom fourcc for internal MPlayer use
179 // sh_video->format = mmioFOURCC('R', 'A', 'D', 'V');
180 sh_video->format = mmioFOURCC('D', 'V', 'S', 'D');
181
182 sh_video->disp_w = dv_decoder->width;
183 sh_video->disp_h = dv_decoder->height;
184 mp_msg(MSGT_DEMUXER,MSGL_V,"demux_open_rawdv() frame_size: %d w: %d h: %d dif_seq: %d system: %d\n",(int)dv_decoder->frame_size,dv_decoder->width, dv_decoder->height,dv_decoder->num_dif_seqs,dv_decoder->system);
185
186 sh_video->fps= (dv_decoder->system==e_dv_system_525_60?29.97:25);
187 sh_video->frametime = 1.0/sh_video->fps;
188
189 // emulate BITMAPINFOHEADER for win32 decoders:
190 sh_video->bih=calloc(1, sizeof(*sh_video->bih));
191 sh_video->bih->biSize=40;
192 sh_video->bih->biWidth = dv_decoder->width;
193 sh_video->bih->biHeight = dv_decoder->height;
194 sh_video->bih->biPlanes=1;
195 sh_video->bih->biBitCount=24;
196 sh_video->bih->biCompression=sh_video->format; // "DVSD"
197 sh_video->bih->biSizeImage=sh_video->bih->biWidth*sh_video->bih->biHeight*3;
198
199
200 frames->current_filepos=0;
201 frames->current_frame=0;
202 frames->frame_size=dv_decoder->frame_size;
203 frames->frame_number=demuxer->stream->end_pos/frames->frame_size;
204
205 mp_msg(MSGT_DEMUXER,MSGL_V,"demux_open_rawdv() seek to %llu, size: %d, dv_dec->frame_size: %d\n",(long long unsigned)frames->current_filepos,frames->frame_size, (int)dv_decoder->frame_size);
206 if (dv_decoder->audio != NULL && demuxer->audio->id>=-1){
207 sh_audio_t *sh_audio = new_sh_audio(demuxer, 0, NULL);
208 demuxer->audio->id = 0;
209 demuxer->audio->sh = sh_audio;
210 mp_msg(MSGT_DEMUXER,MSGL_V,"demux_open_rawdv() chan: %d samplerate: %d\n",dv_decoder->audio->num_channels,dv_decoder->audio->frequency );
211 // custom fourcc for internal MPlayer use
212 sh_audio->format = mmioFOURCC('R', 'A', 'D', 'V');
213
214 sh_audio->wf = calloc(1, sizeof(*sh_audio->wf));
215 sh_audio->wf->wFormatTag = sh_audio->format;
216 sh_audio->wf->nChannels = dv_decoder->audio->num_channels;
217 sh_audio->wf->wBitsPerSample = 16;
218 sh_audio->wf->nSamplesPerSec = dv_decoder->audio->frequency;
219 // info about the input stream:
220 sh_audio->wf->nAvgBytesPerSec = sh_video->fps*dv_decoder->frame_size;
221 sh_audio->wf->nBlockAlign = dv_decoder->frame_size;
222
223 // sh_audio->context=(void*)dv_decoder;
224 }
225 stream_reset(demuxer->stream);
226 stream_seek(demuxer->stream, 0);
227 dv_decoder_free(dv_decoder); //we keep this in the context of both stream headers
228 demuxer->priv=frames;
229 return demuxer;
230
231 err_out:
232 if (dv_decoder) dv_decoder_free(dv_decoder);
233 free(frames);
234 return NULL;
235 }
236
demux_close_rawdv(demuxer_t * demuxer)237 static void demux_close_rawdv(demuxer_t* demuxer)
238 {
239 free(demuxer->priv);
240 demuxer->priv = NULL;
241 }
242
demux_rawdv_control(demuxer_t * demuxer,int cmd,void * arg)243 static int demux_rawdv_control(demuxer_t *demuxer,int cmd, void *arg) {
244 rawdv_frames_t *frames = demuxer->priv;
245 sh_video_t *sh_video=demuxer->video->sh;
246
247 switch(cmd) {
248 case DEMUXER_CTRL_GET_TIME_LENGTH:
249 *(double *)arg=(double)frames->frame_number / sh_video->fps;
250 return DEMUXER_CTRL_OK;
251
252 case DEMUXER_CTRL_GET_PERCENT_POS:
253 *(int *)arg=(int)(frames->current_frame * 100. / frames->frame_number);
254 return DEMUXER_CTRL_OK;
255
256 default:
257 return DEMUXER_CTRL_NOTIMPL;
258 }
259 }
260
261
262 const demuxer_desc_t demuxer_desc_rawdv = {
263 "Raw DV demuxer",
264 "rawdv",
265 "RAWDV",
266 "Alexander Neundorf",
267 "",
268 DEMUXER_TYPE_RAWDV,
269 0, // unsafe autodetect
270 rawdv_check_file,
271 demux_rawdv_fill_buffer,
272 demux_open_rawdv,
273 demux_close_rawdv,
274 demux_seek_rawdv,
275 demux_rawdv_control
276 };
277