2687
|
1 // VIVO file parser by A'rpi
|
2784
|
2 // VIVO text header parser by alex
|
2687
|
3
|
|
4 #include <stdio.h>
|
|
5 #include <stdlib.h>
|
|
6 #include <unistd.h>
|
2928
|
7 #include <string.h> /* strtok */
|
2687
|
8
|
|
9 #include "config.h"
|
|
10 #include "mp_msg.h"
|
|
11 #include "help_mp.h"
|
|
12
|
|
13 #include "stream.h"
|
|
14 #include "demuxer.h"
|
|
15 #include "stheader.h"
|
|
16
|
|
17 #include "bswap.h"
|
|
18
|
|
19 typedef struct {
|
2784
|
20 /* generic */
|
|
21 int supported;
|
|
22 /* info */
|
|
23 char *title;
|
|
24 char *author;
|
|
25 char *copyright;
|
|
26 char *producer;
|
|
27 /* video */
|
|
28 float fps;
|
|
29 int width;
|
|
30 int height;
|
|
31 int disp_width;
|
|
32 int disp_height;
|
|
33 /* audio */
|
|
34 int br;
|
|
35 int samplerate;
|
2687
|
36 } vivo_priv_t;
|
|
37
|
2784
|
38 /* parse all possible extra headers */
|
|
39 /* (audio headers are seperate - mostly with recordtype=3) */
|
|
40 #define TEXTPARSE_ALL 1
|
|
41
|
|
42 static void vivo_parse_text_header(demuxer_t *demux, int header_len)
|
|
43 {
|
|
44 vivo_priv_t* priv = demux->priv;
|
|
45 char *buf;
|
|
46 int i;
|
|
47 char *token;
|
|
48 char *opt, *param;
|
|
49
|
|
50 if (!demux->priv)
|
|
51 {
|
|
52 priv = malloc(sizeof(vivo_priv_t));
|
|
53 memset(priv, 0, sizeof(vivo_priv_t));
|
|
54 demux->priv = priv;
|
|
55 priv->supported = 0;
|
|
56 }
|
|
57
|
|
58 buf = malloc(header_len);
|
|
59 opt = malloc(header_len);
|
|
60 param = malloc(header_len);
|
|
61 stream_read(demux->stream, buf, header_len);
|
|
62 i=0;
|
|
63 while(i<header_len && buf[i]==0x0D && buf[i+1]==0x0A) i+=2; // skip empty lines
|
|
64
|
|
65 token = strtok(buf, (char *)&("\x0d\x0a"));
|
|
66 while (token && (header_len>2))
|
|
67 {
|
|
68 header_len -= strlen(token)+2;
|
|
69 if (sscanf(token, "%[^:]:%[^\n]", opt, param) != 2)
|
|
70 {
|
|
71 mp_msg(MSGT_DEMUX, MSGL_V, "viv_text_header_parser: bad line: '%s' at ~%p\n",
|
|
72 token, stream_tell(demux->stream));
|
|
73 break;
|
|
74 }
|
|
75 mp_msg(MSGT_DEMUX, MSGL_DBG3, "token: '%s' (%d bytes/%d bytes left)\n",
|
|
76 token, strlen(token), header_len);
|
|
77 mp_msg(MSGT_DEMUX, MSGL_DBG3, "token => o: '%s', p: '%s'\n",
|
|
78 opt, param);
|
|
79
|
|
80 /* checking versions: only v1 or v2 is suitable (or known?:) */
|
|
81 if (!strcmp(opt, "Version"))
|
|
82 {
|
|
83 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Version: %s\n", param);
|
2928
|
84 if (!strncmp(param, "Vivo/1", 6) || !strncmp(param, "Vivo/2", 6))
|
|
85 // if (atoi(param) == 1 || atoi(param) == 2)
|
2784
|
86 priv->supported = 1;
|
|
87 }
|
|
88
|
|
89 /* video specific */
|
|
90 if (!strcmp(opt, "FPS"))
|
|
91 {
|
|
92 mp_msg(MSGT_DEMUX, MSGL_DBG2, "FPS: %f\n", atof(param));
|
|
93 priv->fps = atof(param);
|
|
94 }
|
|
95 if (!strcmp(opt, "Width"))
|
|
96 {
|
|
97 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Width: %d\n", atoi(param));
|
|
98 priv->width = atoi(param);
|
|
99 }
|
|
100 if (!strcmp(opt, "Height"))
|
|
101 {
|
|
102 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Height: %d\n", atoi(param));
|
|
103 priv->height = atoi(param);
|
|
104 }
|
|
105 if (!strcmp(opt, "DisplayWidth"))
|
|
106 {
|
|
107 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Display Width: %d\n", atoi(param));
|
|
108 priv->disp_width = atoi(param);
|
|
109 }
|
|
110 if (!strcmp(opt, "DisplayHeight"))
|
|
111 {
|
|
112 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Display Height: %d\n", atoi(param));
|
|
113 priv->disp_height = atoi(param);
|
|
114 }
|
|
115
|
|
116 /* audio specific */
|
|
117 if (!strcmp(opt, "NominalBitrate"))
|
|
118 {
|
|
119 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Bitrate: %d\n", atoi(param));
|
|
120 priv->br = atoi(param);
|
|
121 }
|
|
122 if (!strcmp(opt, "SamplingFrequency"))
|
|
123 {
|
|
124 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Samplerate: %d\n", atoi(param));
|
|
125 priv->samplerate = atoi(param);
|
|
126 }
|
|
127
|
|
128 /* only for displaying some informations about movie*/
|
|
129 if (!strcmp(opt, "Title"))
|
|
130 {
|
|
131 mp_msg(MSGT_DEMUX, MSGL_INFO, " Title: %s\n", param);
|
3068
|
132 demux_info_add(demux, "name", param);
|
2784
|
133 priv->title = malloc(strlen(param));
|
|
134 strcpy(priv->title, param);
|
|
135 }
|
|
136 if (!strcmp(opt, "Author"))
|
|
137 {
|
|
138 mp_msg(MSGT_DEMUX, MSGL_INFO, " Author: %s\n", param);
|
3068
|
139 demux_info_add(demux, "author", param);
|
2784
|
140 priv->author = malloc(strlen(param));
|
|
141 strcpy(priv->author, param);
|
|
142 }
|
|
143 if (!strcmp(opt, "Copyright"))
|
|
144 {
|
|
145 mp_msg(MSGT_DEMUX, MSGL_INFO, " Copyright: %s\n", param);
|
3068
|
146 demux_info_add(demux, "copyright", param);
|
2784
|
147 priv->copyright = malloc(strlen(param));
|
|
148 strcpy(priv->copyright, param);
|
|
149 }
|
|
150 if (!strcmp(opt, "Producer"))
|
|
151 {
|
|
152 mp_msg(MSGT_DEMUX, MSGL_INFO, " Producer: %s\n", param);
|
3069
|
153 demux_info_add(demux, "encoder", param);
|
2784
|
154 priv->producer = malloc(strlen(param));
|
|
155 strcpy(priv->producer, param);
|
|
156 }
|
|
157
|
|
158 /* get next token */
|
|
159 token = strtok(NULL, (char *)&("\x0d\x0a"));
|
|
160 }
|
2788
|
161
|
|
162 if (buf)
|
|
163 free(buf);
|
|
164 if (opt)
|
|
165 free(opt);
|
|
166 if (param)
|
|
167 free(param);
|
2784
|
168 }
|
|
169
|
2687
|
170 int vivo_check_file(demuxer_t* demuxer){
|
|
171 int flags=0;
|
|
172 int i=0;
|
|
173 int len;
|
|
174 int len2;
|
|
175 int c;
|
|
176 unsigned char buf[2048+256];
|
|
177 vivo_priv_t* priv;
|
2784
|
178 int orig_pos = stream_tell(demuxer->stream);
|
2687
|
179
|
|
180 mp_msg(MSGT_DEMUX,MSGL_V,"Checking for VIVO\n");
|
|
181
|
|
182 c=stream_read_char(demuxer->stream);
|
2792
|
183 if(c==-256) return 0;
|
2687
|
184 len=0;
|
|
185 while((c=stream_read_char(demuxer->stream))>=0x80){
|
|
186 len+=0x80*(c-0x80);
|
|
187 if(len>1024) return 0;
|
|
188 }
|
|
189 len+=c;
|
|
190 printf("header block 1 size: %d\n",len);
|
|
191 //stream_skip(demuxer->stream,len);
|
2928
|
192
|
|
193 priv=malloc(sizeof(vivo_priv_t));
|
|
194 memset(priv,0,sizeof(vivo_priv_t));
|
|
195 demuxer->priv=priv;
|
2784
|
196
|
2805
|
197 #if 0
|
2785
|
198 vivo_parse_text_header(demuxer, len);
|
2784
|
199 if (priv->supported == 0)
|
|
200 return 0;
|
|
201 #else
|
2928
|
202 /* this is enought for check (for now) */
|
|
203 stream_read(demuxer->stream,buf,len);
|
|
204 buf[len]=0;
|
|
205 // printf("VIVO header: '%s'\n",buf);
|
|
206
|
2687
|
207 // parse header:
|
|
208 i=0;
|
|
209 while(i<len && buf[i]==0x0D && buf[i+1]==0x0A) i+=2; // skip empty lines
|
2695
|
210 if(strncmp(buf+i,"Version:Vivo/",13)) return 0; // bad version/type!
|
2784
|
211 #endif
|
2687
|
212
|
2695
|
213 #if 0
|
2687
|
214 c=stream_read_char(demuxer->stream);
|
|
215 if(c) return 0;
|
|
216 len2=0;
|
|
217 while((c=stream_read_char(demuxer->stream))>=0x80){
|
|
218 len2+=0x80*(c-0x80);
|
|
219 if(len+len2>2048) return 0;
|
|
220 }
|
|
221 len2+=c;
|
|
222 printf("header block 2 size: %d\n",len2);
|
|
223 stream_skip(demuxer->stream,len2);
|
|
224 // stream_read(demuxer->stream,buf+len,len2);
|
2695
|
225 #endif
|
2687
|
226
|
|
227 // c=stream_read_char(demuxer->stream);
|
|
228 // printf("first packet: %02X\n",c);
|
|
229
|
2784
|
230 stream_seek(demuxer->stream, orig_pos);
|
|
231
|
2687
|
232 return 1;
|
|
233 }
|
|
234
|
|
235 // return value:
|
|
236 // 0 = EOF or no stream found
|
|
237 // 1 = successfully read a packet
|
|
238 int demux_vivo_fill_buffer(demuxer_t *demux){
|
|
239 demux_stream_t *ds=NULL;
|
|
240 int c;
|
|
241 int len=0;
|
|
242 int seq;
|
|
243 demux->filepos=stream_tell(demux->stream);
|
|
244
|
|
245 c=stream_read_char(demux->stream);
|
2792
|
246 if (c == -256) /* EOF */
|
|
247 return 0;
|
2695
|
248 // printf("c=%02X\n",c);
|
2687
|
249 switch(c&0xF0){
|
2695
|
250 case 0x00: // header - skip it!
|
2784
|
251 {
|
2687
|
252 len=stream_read_char(demux->stream);
|
2695
|
253 if(len>=0x80) len=0x80*(len-0x80)+stream_read_char(demux->stream);
|
|
254 printf("vivo extra header: %d bytes\n",len);
|
2784
|
255 #ifdef TEXTPARSE_ALL
|
|
256 {
|
|
257 int pos;
|
|
258 /* also try to parse all headers */
|
|
259 pos = stream_tell(demux->stream);
|
|
260 vivo_parse_text_header(demux, len);
|
|
261 stream_seek(demux->stream, pos);
|
|
262 }
|
|
263 #endif
|
2687
|
264 break;
|
2784
|
265 }
|
2687
|
266 case 0x10: // video packet
|
|
267 len=128;
|
|
268 ds=demux->video;
|
|
269 break;
|
|
270 case 0x20: // video packet
|
|
271 len=stream_read_char(demux->stream);
|
|
272 ds=demux->video;
|
|
273 break;
|
3068
|
274 case 0x30: // audio packet
|
|
275 len=40; /* 40kbps */
|
2695
|
276 ds=demux->audio;
|
|
277 break;
|
2687
|
278 case 0x40: // audio packet
|
3068
|
279 len=24; /* 24kbps */
|
2687
|
280 ds=demux->audio;
|
|
281 break;
|
|
282 default:
|
|
283 mp_msg(MSGT_DEMUX,MSGL_WARN,"VIVO - unknown ID found: %02X contact author!\n",c);
|
|
284 }
|
|
285
|
2695
|
286 if(!ds || ds->id<-1){
|
2687
|
287 if(len) stream_skip(demux->stream,len);
|
|
288 return 1;
|
|
289 }
|
|
290
|
|
291 seq=c&0x0F;
|
|
292
|
|
293 if(ds->asf_packet){
|
|
294 if(ds->asf_seq!=seq){
|
|
295 // closed segment, finalize packet:
|
|
296 ds_add_packet(ds,ds->asf_packet);
|
|
297 ds->asf_packet=NULL;
|
2695
|
298 // printf("packet!\n");
|
2687
|
299 } else {
|
|
300 // append data to it!
|
|
301 demux_packet_t* dp=ds->asf_packet;
|
|
302 dp->buffer=realloc(dp->buffer,dp->len+len);
|
|
303 //memcpy(dp->buffer+dp->len,data,len);
|
|
304 stream_read(demux->stream,dp->buffer+dp->len,len);
|
|
305 mp_dbg(MSGT_DEMUX,MSGL_DBG4,"data appended! %d+%d\n",dp->len,len);
|
|
306 dp->len+=len;
|
|
307 // we are ready now.
|
2695
|
308 if((c&0xF0)==0x20) --ds->asf_seq; // hack!
|
2687
|
309 return 1;
|
|
310 }
|
|
311 }
|
|
312 // create new packet:
|
|
313 { demux_packet_t* dp;
|
|
314 dp=new_demux_packet(len);
|
|
315 //memcpy(dp->buffer,data,len);
|
|
316 stream_read(demux->stream,dp->buffer,len);
|
|
317 // dp->pts=time*0.001f;
|
|
318 // dp->flags=keyframe;
|
|
319 // if(ds==demux->video) printf("ASF time: %8d dur: %5d \n",time,dur);
|
|
320 dp->pos=demux->filepos;
|
|
321 ds->asf_packet=dp;
|
|
322 ds->asf_seq=seq;
|
|
323 // we are ready now.
|
|
324 return 1;
|
|
325 }
|
|
326
|
|
327 }
|
|
328
|
|
329 static const short h263_format[8][2] = {
|
|
330 { 0, 0 },
|
|
331 { 128, 96 },
|
|
332 { 176, 144 },
|
|
333 { 352, 288 },
|
|
334 { 704, 576 },
|
|
335 { 1408, 1152 },
|
2784
|
336 { 320, 240 } // ??????? or 240x180 (found in vivo2) ?
|
2687
|
337 };
|
|
338
|
|
339 static unsigned char* buffer;
|
|
340 static int bufptr=0;
|
|
341 static int bitcnt=0;
|
|
342 static unsigned char buf=0;
|
|
343 static int format, width, height;
|
|
344
|
|
345 static unsigned int x_get_bits(int n){
|
|
346 unsigned int x=0;
|
|
347 while(n-->0){
|
|
348 if(!bitcnt){
|
|
349 // fill buff
|
|
350 buf=buffer[bufptr++];
|
|
351 bitcnt=8;
|
|
352 }
|
|
353 //x=(x<<1)|(buf&1);buf>>=1;
|
|
354 x=(x<<1)|(buf>>7);buf<<=1;
|
|
355 --bitcnt;
|
|
356 }
|
|
357 return x;
|
|
358 }
|
|
359
|
|
360 #define get_bits(xxx,n) x_get_bits(n)
|
|
361 #define get_bits1(xxx) x_get_bits(1)
|
|
362 #define skip_bits(xxx,n) x_get_bits(n)
|
|
363 #define skip_bits1(xxx) x_get_bits(1)
|
|
364
|
|
365 /* most is hardcoded. should extend to handle all h263 streams */
|
|
366 static int h263_decode_picture_header(unsigned char *b_ptr)
|
|
367 {
|
2928
|
368 // int i;
|
2695
|
369
|
|
370 // for(i=0;i<16;i++) printf(" %02X",b_ptr[i]); printf("\n");
|
2687
|
371
|
|
372 buffer=b_ptr;
|
|
373 bufptr=bitcnt=buf=0;
|
|
374
|
|
375 /* picture header */
|
2695
|
376 if (get_bits(&s->gb, 22) != 0x20){
|
|
377 printf("bad picture header\n");
|
2687
|
378 return -1;
|
2695
|
379 }
|
2687
|
380 skip_bits(&s->gb, 8); /* picture timestamp */
|
|
381
|
2695
|
382 if (get_bits1(&s->gb) != 1){
|
|
383 printf("bad marker\n");
|
2687
|
384 return -1; /* marker */
|
2695
|
385 }
|
|
386 if (get_bits1(&s->gb) != 0){
|
|
387 printf("bad h263 id\n");
|
2687
|
388 return -1; /* h263 id */
|
2695
|
389 }
|
2687
|
390 skip_bits1(&s->gb); /* split screen off */
|
|
391 skip_bits1(&s->gb); /* camera off */
|
|
392 skip_bits1(&s->gb); /* freeze picture release off */
|
|
393
|
|
394 format = get_bits(&s->gb, 3);
|
|
395
|
|
396 if (format != 7) {
|
|
397 printf("h263_plus = 0 format = %d\n",format);
|
|
398 /* H.263v1 */
|
|
399 width = h263_format[format][0];
|
|
400 height = h263_format[format][1];
|
|
401 printf("%d x %d\n",width,height);
|
2695
|
402 // if (!width) return -1;
|
2687
|
403
|
|
404 printf("pict_type=%d\n",get_bits1(&s->gb));
|
|
405 printf("unrestricted_mv=%d\n",get_bits1(&s->gb));
|
|
406 #if 1
|
|
407 printf("SAC: %d\n",get_bits1(&s->gb));
|
|
408 printf("advanced prediction mode: %d\n",get_bits1(&s->gb));
|
|
409 printf("PB frame: %d\n",get_bits1(&s->gb));
|
|
410 #else
|
|
411 if (get_bits1(&s->gb) != 0)
|
|
412 return -1; /* SAC: off */
|
|
413 if (get_bits1(&s->gb) != 0)
|
|
414 return -1; /* advanced prediction mode: off */
|
|
415 if (get_bits1(&s->gb) != 0)
|
|
416 return -1; /* not PB frame */
|
|
417 #endif
|
|
418 printf("qscale=%d\n",get_bits(&s->gb, 5));
|
|
419 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
|
|
420 } else {
|
|
421 printf("h263_plus = 1\n");
|
|
422 /* H.263v2 */
|
2695
|
423 if (get_bits(&s->gb, 3) != 1){
|
|
424 printf("H.263v2 A error\n");
|
2687
|
425 return -1;
|
2695
|
426 }
|
|
427 if (get_bits(&s->gb, 3) != 6){ /* custom source format */
|
|
428 printf("custom source format\n");
|
2687
|
429 return -1;
|
2695
|
430 }
|
2687
|
431 skip_bits(&s->gb, 12);
|
|
432 skip_bits(&s->gb, 3);
|
|
433 printf("pict_type=%d\n",get_bits(&s->gb, 3) + 1);
|
|
434 // if (s->pict_type != I_TYPE &&
|
|
435 // s->pict_type != P_TYPE)
|
|
436 // return -1;
|
|
437 skip_bits(&s->gb, 7);
|
|
438 skip_bits(&s->gb, 4); /* aspect ratio */
|
|
439 width = (get_bits(&s->gb, 9) + 1) * 4;
|
|
440 skip_bits1(&s->gb);
|
|
441 height = get_bits(&s->gb, 9) * 4;
|
|
442 printf("%d x %d\n",width,height);
|
2695
|
443 //if (height == 0)
|
|
444 // return -1;
|
2687
|
445 printf("qscale=%d\n",get_bits(&s->gb, 5));
|
|
446 }
|
|
447
|
|
448 /* PEI */
|
|
449 while (get_bits1(&s->gb) != 0) {
|
|
450 skip_bits(&s->gb, 8);
|
|
451 }
|
|
452 // s->f_code = 1;
|
|
453 // s->width = width;
|
|
454 // s->height = height;
|
|
455 return 0;
|
|
456 }
|
|
457
|
|
458
|
2695
|
459
|
2687
|
460 void demux_open_vivo(demuxer_t* demuxer){
|
|
461 vivo_priv_t* priv=demuxer->priv;
|
|
462
|
|
463 if(!ds_fill_buffer(demuxer->video)){
|
|
464 mp_msg(MSGT_DEMUX,MSGL_ERR,"VIVO: " MSGTR_MissingVideoStreamBug);
|
|
465 return;
|
|
466 }
|
|
467
|
|
468 h263_decode_picture_header(demuxer->video->buffer);
|
|
469
|
|
470
|
|
471 { sh_video_t* sh=new_sh_video(demuxer,0);
|
|
472
|
|
473 sh->format=0x6f766976; // "vivo"
|
2784
|
474 if(!sh->fps)
|
2928
|
475 {
|
2784
|
476 if (priv->fps)
|
|
477 sh->fps=priv->fps;
|
|
478 else
|
|
479 sh->fps=15.0f;
|
2928
|
480 }
|
2687
|
481 sh->frametime=1.0f/sh->fps;
|
2805
|
482
|
|
483 #warning "FIXME! we can't scale"
|
|
484 priv->disp_width = priv->width;
|
|
485 priv->disp_height = priv->height;
|
|
486
|
2784
|
487 if (priv->disp_width)
|
|
488 sh->disp_w = priv->disp_width;
|
|
489 else
|
|
490 sh->disp_w = width;
|
|
491 if (priv->disp_height)
|
|
492 sh->disp_h = priv->disp_height;
|
|
493 else
|
|
494 sh->disp_h = height;
|
2687
|
495
|
|
496 // emulate BITMAPINFOHEADER:
|
|
497 sh->bih=malloc(sizeof(BITMAPINFOHEADER));
|
|
498 memset(sh->bih,0,sizeof(BITMAPINFOHEADER));
|
|
499 sh->bih->biSize=40;
|
2784
|
500 if (priv->width)
|
|
501 sh->bih->biWidth = priv->width;
|
|
502 else
|
|
503 sh->bih->biWidth = width;
|
|
504 if (priv->height)
|
|
505 sh->bih->biHeight = priv->height;
|
|
506 else
|
|
507 sh->bih->biHeight = height;
|
2687
|
508 sh->bih->biPlanes=1;
|
|
509 sh->bih->biBitCount=24;
|
|
510 sh->bih->biCompression=sh->format;
|
|
511 sh->bih->biSizeImage=sh->bih->biWidth*sh->bih->biHeight*3;
|
|
512 demuxer->video->sh=sh; sh->ds=demuxer->video;
|
|
513 demuxer->video->id=0;
|
2928
|
514
|
|
515 demuxer->seekable = 0;
|
2788
|
516
|
2928
|
517 printf("VIVO Video stream %d size: display: %dx%d, codec: %lux%lu\n",
|
2788
|
518 demuxer->video->id, sh->disp_w, sh->disp_h, sh->bih->biWidth,
|
|
519 sh->bih->biHeight);
|
2687
|
520 }
|
|
521
|
2695
|
522 if(demuxer->audio->id>=-1){
|
2687
|
523 if(!ds_fill_buffer(demuxer->audio)){
|
|
524 mp_msg(MSGT_DEMUX,MSGL_ERR,"VIVO: " MSGTR_MissingAudioStream);
|
|
525 } else
|
|
526 { sh_audio_t* sh=new_sh_audio(demuxer,1);
|
2788
|
527
|
2687
|
528 sh->format=0x111; // 0x112
|
3068
|
529 // if (sh->format == 0x111) /* G.723 */
|
|
530 // sh->samplesize = demuxer->audio->buffer_size;
|
|
531 // printf("samplesize: %d\n", sh->samplesize);
|
2687
|
532 // Emulate WAVEFORMATEX struct:
|
|
533 sh->wf=malloc(sizeof(WAVEFORMATEX));
|
|
534 memset(sh->wf,0,sizeof(WAVEFORMATEX));
|
|
535 sh->wf->nChannels=1;
|
|
536 sh->wf->wBitsPerSample=16;
|
2788
|
537 // sh->wf->wBitsPerSample=8;
|
2784
|
538 if (priv->samplerate)
|
|
539 sh->wf->nSamplesPerSec=priv->samplerate;
|
|
540 else
|
|
541 sh->wf->nSamplesPerSec=22050;
|
2788
|
542 // sh->wf->nSamplesPerSec=8000;
|
2687
|
543 sh->wf->nAvgBytesPerSec=sh->wf->nChannels*sh->wf->wBitsPerSample*sh->wf->nSamplesPerSec/8;
|
|
544 demuxer->audio->sh=sh; sh->ds=demuxer->audio;
|
|
545 demuxer->audio->id=1;
|
|
546 }
|
2695
|
547 }
|
2687
|
548
|
|
549 }
|
|
550
|
2788
|
551 void demux_close_vivo(demuxer_t *demuxer)
|
|
552 {
|
|
553 vivo_priv_t* priv=demuxer->priv;
|
2809
|
554
|
|
555 if (priv) {
|
|
556 if (priv->title)
|
|
557 free(priv->title);
|
|
558 if (priv->author)
|
|
559 free(priv->author);
|
|
560 if (priv->copyright)
|
|
561 free(priv->copyright);
|
|
562 if (priv->producer)
|
|
563 free(priv->producer);
|
2788
|
564 free(priv);
|
2809
|
565 }
|
2788
|
566 return;
|
|
567 }
|