libmpdemux/demux_viv.c

   1 //  VIVO file parser by A'rpi
   2 //  VIVO text header parser and audio support by alex
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <unistd.h>
   7 #include <string.h> /* strtok */
   8
   9 #include "config.h"
  10 #include "mp_msg.h"
  11 #include "help_mp.h"
  12
  13 #include "stream/stream.h"
  14 #include "demuxer.h"
  15 #include "stheader.h"
  16
  17 /* parameters ! */
  18 int vivo_param_version = -1;
  19 char *vivo_param_acodec = NULL;
  20 int vivo_param_abitrate = -1;
  21 int vivo_param_samplerate = -1;
  22 int vivo_param_bytesperblock = -1;
  23 int vivo_param_width = -1;
  24 int vivo_param_height = -1;
  25 int vivo_param_vformat = -1;
  26
  27 /* VIVO audio standards from vivog723.acm:
  28
  29     G.723:
  30         FormatTag = 0x111
  31         Channels = 1 - mono
  32         SamplesPerSec = 8000 - 8khz
  33         AvgBytesPerSec = 800
  34         BlockAlign (bytes per block) = 24
  35         BitsPerSample = 8
  36
  37     Siren:
  38         FormatTag = 0x112
  39         Channels = 1 - mono
  40         SamplesPerSec = 16000 - 16khz
  41         AvgBytesPerSec = 2000
  42         BlockAlign (bytes per block) = 40
  43         BitsPerSample = 8
  44 */
  45
  46 //enum { VIVO_AUDIO_G723, VIVO_AUDIO_SIREN };
  47
  48 #define VIVO_AUDIO_G723 1
  49 #define VIVO_AUDIO_SIREN 2
  50
  51 typedef struct {
  52     /* generic */
  53     char        version;
  54     int         supported;
  55     /* info */
  56     char        *title;
  57     char        *author;
  58     char        *copyright;
  59     char        *producer;
  60     /* video */
  61     float       fps;
  62     int         width;
  63     int         height;
  64     int         disp_width;
  65     int         disp_height;
  66     /* audio */
  67     int         audio_codec;
  68     int         audio_bitrate;
  69     int         audio_samplerate;
  70     int         audio_bytesperblock;
  71 } vivo_priv_t;
  72
  73 /* parse all possible extra headers */
  74 /* (audio headers are separate - mostly with recordtype=3 or 4) */
  75 #define TEXTPARSE_ALL 1
  76
  77 static void vivo_parse_text_header(demuxer_t *demux, int header_len)
  78 {
  79     vivo_priv_t* priv = demux->priv;
  80     char *buf;
  81     int i;
  82     char *token;
  83     char *opt, *param;
  84     int parser_in_audio_block = 0;
  85
  86     if (!demux->priv)
  87     {
  88         priv = malloc(sizeof(vivo_priv_t));
  89         memset(priv, 0, sizeof(vivo_priv_t));
  90         demux->priv = priv;
  91         priv->supported = 0;
  92     }
  93
  94     buf = malloc(header_len);
  95     opt = malloc(header_len);
  96     param = malloc(header_len);
  97     stream_read(demux->stream, buf, header_len);
  98     i=0;
  99     while(i<header_len && buf[i]==0x0D && buf[i+1]==0x0A) i+=2; // skip empty lines
 100
 101     token = strtok(buf, (char *)&("\x0d\x0a"));
 102     while (token && (header_len>2))
 103     {
 104         header_len -= strlen(token)+2;
 105         if (sscanf(token, "%[^:]:%[^\n]", opt, param) != 2)
 106         {
 107             mp_msg(MSGT_DEMUX, MSGL_V, "viv_text_header_parser: bad line: '%s' at ~%#"PRIx64"\n",
 108                 token, (int64_t)stream_tell(demux->stream));
 109             break;
 110         }
 111         mp_dbg(MSGT_DEMUX, MSGL_DBG3, "token: '%s' (%d bytes/%d bytes left)\n",
 112             token, strlen(token), header_len);
 113         mp_dbg(MSGT_DEMUX, MSGL_DBG3, "token => o: '%s', p: '%s'\n",
 114             opt, param);
 115
 116         /* checking versions: only v1 or v2 is suitable (or known?:) */
 117         if (!strcmp(opt, "Version"))
 118         {
 119             mp_msg(MSGT_DEMUX, MSGL_DBG2, "Version: %s\n", param);
 120             if (!strncmp(param, "Vivo/1", 6) || !strncmp(param, "Vivo/2", 6))
 121             {
 122                 priv->supported = 1;
 123                 /* save major version for fourcc */
 124                 priv->version = param[5];
 125             }
 126         }
 127
 128         /* video specific */
 129         if (!strcmp(opt, "FPS"))
 130         {
 131             mp_msg(MSGT_DEMUX, MSGL_DBG2, "FPS: %f\n", atof(param));
 132             priv->fps = atof(param);
 133         }
 134         if (!strcmp(opt, "Width"))
 135         {
 136             mp_msg(MSGT_DEMUX, MSGL_DBG2, "Width: %d\n", atoi(param));
 137             priv->width = atoi(param);
 138         }
 139         if (!strcmp(opt, "Height"))
 140         {
 141             mp_msg(MSGT_DEMUX, MSGL_DBG2, "Height: %d\n", atoi(param));
 142             priv->height = atoi(param);
 143         }
 144         if (!strcmp(opt, "DisplayWidth"))
 145         {
 146             mp_msg(MSGT_DEMUX, MSGL_DBG2, "Display Width: %d\n", atoi(param));
 147             priv->disp_width = atoi(param);
 148         }
 149         if (!strcmp(opt, "DisplayHeight"))
 150         {
 151             mp_msg(MSGT_DEMUX, MSGL_DBG2, "Display Height: %d\n", atoi(param));
 152             priv->disp_height = atoi(param);
 153         }
 154
 155         /* audio specific */
 156         if (!strcmp(opt, "RecordType"))
 157         {
 158             /* no audio recordblock by Vivo/1.00, 3 and 4 by Vivo/2.00 */
 159             if ((atoi(param) == 3) || (atoi(param) == 4))
 160                 parser_in_audio_block = 1;
 161             else
 162                 parser_in_audio_block = 0;
 163         }
 164         if (!strcmp(opt, "NominalBitrate"))
 165         {
 166             priv->audio_bitrate = atoi(param);
 167             if (priv->audio_bitrate == 2000)
 168                 priv->audio_codec = VIVO_AUDIO_SIREN;
 169             if (priv->audio_bitrate == 800)
 170                 priv->audio_codec = VIVO_AUDIO_G723;
 171         }
 172         if (!strcmp(opt, "SamplingFrequency"))
 173         {
 174             priv->audio_samplerate = atoi(param);
 175             if (priv->audio_samplerate == 16000)
 176                 priv->audio_codec = VIVO_AUDIO_SIREN;
 177             if (priv->audio_samplerate == 8000)
 178                 priv->audio_codec = VIVO_AUDIO_G723;
 179         }
 180         if (!strcmp(opt, "Length") && (parser_in_audio_block == 1))
 181         {
 182             priv->audio_bytesperblock = atoi(param); /* 24 or 40 kbps */
 183             if (priv->audio_bytesperblock == 40)
 184                 priv->audio_codec = VIVO_AUDIO_SIREN;
 185             if (priv->audio_bytesperblock == 24)
 186                 priv->audio_codec = VIVO_AUDIO_G723;
 187         }
 188
 189         /* only for displaying some informations about movie*/
 190         if (!strcmp(opt, "Title"))
 191         {
 192             demux_info_add(demux, "name", param);
 193             priv->title = strdup(param);
 194         }
 195         if (!strcmp(opt, "Author"))
 196         {
 197             demux_info_add(demux, "author", param);
 198             priv->author = strdup(param);
 199         }
 200         if (!strcmp(opt, "Copyright"))
 201         {
 202             demux_info_add(demux, "copyright", param);
 203             priv->copyright = strdup(param);
 204         }
 205         if (!strcmp(opt, "Producer"))
 206         {
 207             demux_info_add(demux, "encoder", param);
 208             priv->producer = strdup(param);
 209         }
 210
 211         /* get next token */
 212         token = strtok(NULL, (char *)&("\x0d\x0a"));
 213     }
 214
 215     if (buf)
 216         free(buf);
 217     if (opt)
 218         free(opt);
 219     if (param)
 220         free(param);
 221 }
 222
 223 static int vivo_check_file(demuxer_t* demuxer){
 224     int i=0;
 225     int len;
 226     int c;
 227     unsigned char buf[2048+256];
 228     vivo_priv_t* priv;
 229     int orig_pos = stream_tell(demuxer->stream);
 230
 231     mp_msg(MSGT_DEMUX,MSGL_V,"Checking for VIVO\n");
 232
 233     c=stream_read_char(demuxer->stream);
 234     if(c==-256) return 0;
 235     len=0;
 236     while((c=stream_read_char(demuxer->stream))>=0x80){
 237         len+=0x80*(c-0x80);
 238         if(len>1024) return 0;
 239     }
 240     len+=c;
 241     mp_msg(MSGT_DEMUX,MSGL_V,"header block 1 size: %d\n",len);
 242     //stream_skip(demuxer->stream,len);
 243
 244     priv=malloc(sizeof(vivo_priv_t));
 245     memset(priv,0,sizeof(vivo_priv_t));
 246     demuxer->priv=priv;
 247
 248 #if 0
 249     vivo_parse_text_header(demuxer, len);
 250     if (priv->supported == 0)
 251         return 0;
 252 #else
 253     /* this is enought for check (for now) */
 254     stream_read(demuxer->stream,buf,len);
 255     buf[len]=0;
 256 //    printf("VIVO header: '%s'\n",buf);
 257
 258     // parse header:
 259     i=0;
 260     while(i<len && buf[i]==0x0D && buf[i+1]==0x0A) i+=2; // skip empty lines
 261     if(strncmp(buf+i,"Version:Vivo/",13)) return 0; // bad version/type!
 262 #endif
 263
 264 #if 0
 265     c=stream_read_char(demuxer->stream);
 266     if(c) return 0;
 267     len2=0;
 268     while((c=stream_read_char(demuxer->stream))>=0x80){
 269         len2+=0x80*(c-0x80);
 270         if(len+len2>2048) return 0;
 271     }
 272     len2+=c;
 273     mp_msg(MSGT_DEMUX,MSGL_V,"header block 2 size: %d\n",len2);
 274     stream_skip(demuxer->stream,len2);
 275 //    stream_read(demuxer->stream,buf+len,len2);
 276 #endif
 277
 278 //    c=stream_read_char(demuxer->stream);
 279 //    printf("first packet: %02X\n",c);
 280
 281     stream_seek(demuxer->stream, orig_pos);
 282
 283 return DEMUXER_TYPE_VIVO;
 284 }
 285
 286 static int audio_pos=0;
 287 static int audio_rate=0;
 288
 289 // return value:
 290 //     0 = EOF or no stream found
 291 //     1 = successfully read a packet
 292 static int demux_vivo_fill_buffer(demuxer_t *demux, demux_stream_t *dsds){
 293   demux_stream_t *ds=NULL;
 294   int c;
 295   int len=0;
 296   int seq;
 297   int prefix=0;
 298   demux->filepos=stream_tell(demux->stream);
 299
 300   c=stream_read_char(demux->stream);
 301   if (c == -256) /* EOF */
 302     return 0;
 303 //  printf("c=%x,%02X\n",c,c&0xf0);
 304   if (c == 0x82)
 305   {
 306       /* ok, this works, but pts calculating from header is required! */
 307 #warning "Calculate PTS from picture header!"
 308       prefix = 1;
 309       c = stream_read_char(demux->stream);
 310       mp_msg(MSGT_DEMUX, MSGL_V, "packet 0x82(pos=%u) chunk=%x\n",
 311         (int)stream_tell(demux->stream), c);
 312   }
 313   switch(c&0xF0){
 314   case 0x00: // header - skip it!
 315   {
 316       len=stream_read_char(demux->stream);
 317       if(len>=0x80) len=0x80*(len-0x80)+stream_read_char(demux->stream);
 318       mp_msg(MSGT_DEMUX, MSGL_V, "vivo extra header: %d bytes\n",len);
 319 #ifdef TEXTPARSE_ALL
 320 {
 321       int pos;
 322       /* also try to parse all headers */
 323       pos = stream_tell(demux->stream);
 324       vivo_parse_text_header(demux, len);
 325       stream_seek(demux->stream, pos);
 326 }
 327 #endif
 328       break;
 329   }
 330   case 0x10:  // video packet
 331       if (prefix == 1)
 332         len = stream_read_char(demux->stream);
 333       else
 334         len=128;
 335       ds=demux->video;
 336       break;
 337   case 0x20:  // video packet
 338       len=stream_read_char(demux->stream);
 339       ds=demux->video;
 340       break;
 341   case 0x30:  // audio packet
 342       if (prefix == 1)
 343         len = stream_read_char(demux->stream);
 344       else
 345         len=40; /* 40kbps */
 346       ds=demux->audio;
 347       audio_pos+=len;
 348       break;
 349   case 0x40:  // audio packet
 350       if (prefix == 1)
 351         len = stream_read_char(demux->stream);
 352       else
 353         len=24; /* 24kbps */
 354       ds=demux->audio;
 355       audio_pos+=len;
 356       break;
 357   default:
 358       mp_msg(MSGT_DEMUX,MSGL_WARN,"VIVO - unknown ID found: %02X at pos %"PRIu64" contact author!\n",
 359         c, (int64_t)stream_tell(demux->stream));
 360       return 0;
 361   }
 362
 363 //  printf("chunk=%x, len=%d\n", c, len);
 364
 365   if(!ds || ds->id<-1){
 366       if(len) stream_skip(demux->stream,len);
 367       return 1;
 368   }
 369
 370   seq=c&0x0F;
 371
 372     if(ds->asf_packet){
 373       if(ds->asf_seq!=seq){
 374         // closed segment, finalize packet:
 375         ds_add_packet(ds,ds->asf_packet);
 376         ds->asf_packet=NULL;
 377 //      printf("packet!\n");
 378       } else {
 379         // append data to it!
 380         demux_packet_t* dp=ds->asf_packet;
 381         if(dp->len + len + MP_INPUT_BUFFER_PADDING_SIZE < 0)
 382             return 0;
 383         dp->buffer=realloc(dp->buffer,dp->len+len+MP_INPUT_BUFFER_PADDING_SIZE);
 384         memset(dp->buffer+dp->len+len, 0, MP_INPUT_BUFFER_PADDING_SIZE);
 385         //memcpy(dp->buffer+dp->len,data,len);
 386         stream_read(demux->stream,dp->buffer+dp->len,len);
 387         mp_dbg(MSGT_DEMUX,MSGL_DBG4,"data appended! %d+%d\n",dp->len,len);
 388         dp->len+=len;
 389         // we are ready now.
 390         if((c&0xF0)==0x20) --ds->asf_seq; // hack!
 391         return 1;
 392       }
 393     }
 394     // create new packet:
 395     { demux_packet_t* dp;
 396       dp=new_demux_packet(len);
 397       //memcpy(dp->buffer,data,len);
 398       stream_read(demux->stream,dp->buffer,len);
 399       dp->pts=audio_rate?((float)audio_pos/(float)audio_rate):0;
 400 //      dp->flags=keyframe;
 401 //      if(ds==demux->video) printf("ASF time: %8d  dur: %5d  \n",time,dur);
 402       dp->pos=demux->filepos;
 403       ds->asf_packet=dp;
 404       ds->asf_seq=seq;
 405       // we are ready now.
 406       return 1;
 407     }
 408
 409 }
 410
 411 static const short h263_format[8][2] = {
 412     { 0, 0 },
 413     { 128, 96 },
 414     { 176, 144 },
 415     { 352, 288 },
 416     { 704, 576 },
 417     { 1408, 1152 },
 418     { 320, 240 }   // ??????? or 240x180 (found in vivo2) ?
 419 };
 420
 421 static unsigned char* buffer;
 422 static int bufptr=0;
 423 static int bitcnt=0;
 424 static unsigned char buf=0;
 425 static int format, width, height;
 426
 427 static unsigned int x_get_bits(int n){
 428     unsigned int x=0;
 429     while(n-->0){
 430         if(!bitcnt){
 431             // fill buff
 432             buf=buffer[bufptr++];
 433             bitcnt=8;
 434         }
 435         //x=(x<<1)|(buf&1);buf>>=1;
 436         x=(x<<1)|(buf>>7);buf<<=1;
 437         --bitcnt;
 438     }
 439     return x;
 440 }
 441
 442 #define get_bits(xxx,n) x_get_bits(n)
 443 #define get_bits1(xxx) x_get_bits(1)
 444 #define skip_bits(xxx,n) x_get_bits(n)
 445 #define skip_bits1(xxx) x_get_bits(1)
 446
 447 /* most is hardcoded. should extend to handle all h263 streams */
 448 static int h263_decode_picture_header(unsigned char *b_ptr)
 449 {
 450 //    int i;
 451
 452 //    for(i=0;i<16;i++) printf(" %02X",b_ptr[i]); printf("\n");
 453
 454     buffer=b_ptr;
 455     bufptr=bitcnt=buf=0;
 456
 457     /* picture header */
 458     if (get_bits(&s->gb, 22) != 0x20){
 459         mp_msg(MSGT_DEMUX, MSGL_FATAL, "bad picture header\n");
 460         return -1;
 461     }
 462     skip_bits(&s->gb, 8); /* picture timestamp */
 463
 464     if (get_bits1(&s->gb) != 1){
 465         mp_msg(MSGT_DEMUX, MSGL_FATAL, "bad marker\n");
 466         return -1;      /* marker */
 467     }
 468     if (get_bits1(&s->gb) != 0){
 469         mp_msg(MSGT_DEMUX, MSGL_FATAL, "bad h263 id\n");
 470         return -1;      /* h263 id */
 471     }
 472     skip_bits1(&s->gb); /* split screen off */
 473     skip_bits1(&s->gb); /* camera  off */
 474     skip_bits1(&s->gb); /* freeze picture release off */
 475
 476     format = get_bits(&s->gb, 3);
 477
 478     if (format != 7) {
 479         mp_msg(MSGT_DEMUX, MSGL_V, "h263_plus = 0  format = %d\n", format);
 480         /* H.263v1 */
 481         width = h263_format[format][0];
 482         height = h263_format[format][1];
 483         mp_msg(MSGT_DEMUX, MSGL_V, "%d x %d\n", width, height);
 484 //        if (!width) return -1;
 485
 486         mp_msg(MSGT_DEMUX, MSGL_V, "pict_type=%d\n", get_bits1(&s->gb));
 487         mp_msg(MSGT_DEMUX, MSGL_V, "unrestricted_mv=%d\n", get_bits1(&s->gb));
 488 #if 1
 489         mp_msg(MSGT_DEMUX, MSGL_V, "SAC: %d\n", get_bits1(&s->gb));
 490         mp_msg(MSGT_DEMUX, MSGL_V, "advanced prediction mode: %d\n", get_bits1(&s->gb));
 491         mp_msg(MSGT_DEMUX, MSGL_V, "PB frame: %d\n", get_bits1(&s->gb));
 492 #else
 493         if (get_bits1(&s->gb) != 0)
 494             return -1;  /* SAC: off */
 495         if (get_bits1(&s->gb) != 0)
 496             return -1;  /* advanced prediction mode: off */
 497         if (get_bits1(&s->gb) != 0)
 498             return -1;  /* not PB frame */
 499 #endif
 500         mp_msg(MSGT_DEMUX, MSGL_V, "qscale=%d\n", get_bits(&s->gb, 5));
 501         skip_bits1(&s->gb);     /* Continuous Presence Multipoint mode: off */
 502     } else {
 503         mp_msg(MSGT_DEMUX, MSGL_V, "h263_plus = 1\n");
 504         /* H.263v2 */
 505         if (get_bits(&s->gb, 3) != 1){
 506             mp_msg(MSGT_DEMUX, MSGL_FATAL, "H.263v2 A error\n");
 507             return -1;
 508         }
 509         if (get_bits(&s->gb, 3) != 6){ /* custom source format */
 510             mp_msg(MSGT_DEMUX, MSGL_FATAL, "custom source format\n");
 511             return -1;
 512         }
 513         skip_bits(&s->gb, 12);
 514         skip_bits(&s->gb, 3);
 515         mp_msg(MSGT_DEMUX, MSGL_V, "pict_type=%d\n", get_bits(&s->gb, 3) + 1);
 516 //        if (s->pict_type != I_TYPE &&
 517 //            s->pict_type != P_TYPE)
 518 //            return -1;
 519         skip_bits(&s->gb, 7);
 520         skip_bits(&s->gb, 4); /* aspect ratio */
 521         width = (get_bits(&s->gb, 9) + 1) * 4;
 522         skip_bits1(&s->gb);
 523         height = get_bits(&s->gb, 9) * 4;
 524         mp_msg(MSGT_DEMUX, MSGL_V, "%d x %d\n", width, height);
 525         //if (height == 0)
 526         //    return -1;
 527         mp_msg(MSGT_DEMUX, MSGL_V, "qscale=%d\n", get_bits(&s->gb, 5));
 528     }
 529
 530     /* PEI */
 531     while (get_bits1(&s->gb) != 0) {
 532         skip_bits(&s->gb, 8);
 533     }
 534 //    s->f_code = 1;
 535 //    s->width = width;
 536 //    s->height = height;
 537     return 0;
 538 }
 539
 540
 541
 542 static demuxer_t* demux_open_vivo(demuxer_t* demuxer){
 543     vivo_priv_t* priv=demuxer->priv;
 544
 545   if(!ds_fill_buffer(demuxer->video)){
 546     mp_msg(MSGT_DEMUX,MSGL_ERR,"VIVO: " MSGTR_MissingVideoStreamBug);
 547     return NULL;
 548   }
 549
 550     audio_pos=0;
 551
 552   h263_decode_picture_header(demuxer->video->buffer);
 553
 554   if (vivo_param_version != -1)
 555     priv->version = '0' + vivo_param_version;
 556
 557 {               sh_video_t* sh=new_sh_video(demuxer,0);
 558
 559                 /* viv1, viv2 (for better codecs.conf) */
 560                 sh->format = mmioFOURCC('v', 'i', 'v', priv->version);
 561                 if(!sh->fps)
 562                 {
 563                     if (priv->fps)
 564                         sh->fps=priv->fps;
 565                     else
 566                         sh->fps=15.0f;
 567                 }
 568                 sh->frametime=1.0f/sh->fps;
 569
 570                 /* XXX: FIXME: can't scale image. */
 571                 /* hotfix to disable: */
 572                 priv->disp_width = priv->width;
 573                 priv->disp_height = priv->height;
 574
 575                 if (vivo_param_width != -1)
 576                     priv->disp_width = priv->width = vivo_param_width;
 577
 578                 if (vivo_param_height != -1)
 579                     priv->disp_height = priv->height = vivo_param_height;
 580
 581                 if (vivo_param_vformat != -1)
 582                 {
 583                     priv->disp_width = priv->width = h263_format[vivo_param_vformat][0];
 584                     priv->disp_height = priv->height = h263_format[vivo_param_vformat][1];
 585                 }
 586
 587                 if (priv->disp_width)
 588                     sh->disp_w = priv->disp_width;
 589                 else
 590                     sh->disp_w = width;
 591                 if (priv->disp_height)
 592                     sh->disp_h = priv->disp_height;
 593                 else
 594                     sh->disp_h = height;
 595
 596                 // emulate BITMAPINFOHEADER:
 597                 sh->bih=malloc(sizeof(BITMAPINFOHEADER));
 598                 memset(sh->bih,0,sizeof(BITMAPINFOHEADER));
 599                 sh->bih->biSize=40;
 600                 if (priv->width)
 601                     sh->bih->biWidth = priv->width;
 602                 else
 603                     sh->bih->biWidth = width;
 604                 if (priv->height)
 605                     sh->bih->biHeight = priv->height;
 606                 else
 607                     sh->bih->biHeight = height;
 608                 sh->bih->biPlanes=1;
 609                 sh->bih->biBitCount=24;
 610                 sh->bih->biCompression=sh->format;
 611                 sh->bih->biSizeImage=sh->bih->biWidth*sh->bih->biHeight*3;
 612
 613                 /* insert as stream */
 614                 demuxer->video->sh=sh;
 615                 sh->ds=demuxer->video;
 616                 demuxer->video->id=0;
 617
 618                 /* disable seeking */
 619                 demuxer->seekable = 0;
 620
 621                 mp_msg(MSGT_DEMUX,MSGL_V,"VIVO Video stream %d size: display: %dx%d, codec: %ux%u\n",
 622                     demuxer->video->id, sh->disp_w, sh->disp_h, sh->bih->biWidth,
 623                     sh->bih->biHeight);
 624 }
 625
 626 /* AUDIO init */
 627 if (demuxer->audio->id >= -1){
 628   if(!ds_fill_buffer(demuxer->audio)){
 629     mp_msg(MSGT_DEMUX,MSGL_ERR,"VIVO: " MSGTR_MissingAudioStream);
 630   } else
 631 {               sh_audio_t* sh=new_sh_audio(demuxer,1);
 632
 633                 /* Select audio codec */
 634                 if (priv->audio_codec == 0)
 635                 {
 636                     if (priv->version == '2')
 637                         priv->audio_codec = VIVO_AUDIO_SIREN;
 638                     else
 639                         priv->audio_codec = VIVO_AUDIO_G723;
 640                 }
 641                 if (vivo_param_acodec != NULL)
 642                 {
 643                     if (!strcasecmp(vivo_param_acodec, "g723"))
 644                         priv->audio_codec = VIVO_AUDIO_G723;
 645                     if (!strcasecmp(vivo_param_acodec, "siren"))
 646                         priv->audio_codec = VIVO_AUDIO_SIREN;
 647                 }
 648
 649                 if (priv->audio_codec == VIVO_AUDIO_G723)
 650                     sh->format = 0x111;
 651                 else if (priv->audio_codec == VIVO_AUDIO_SIREN)
 652                     sh->format = 0x112;
 653                 else
 654                 {
 655                     mp_msg(MSGT_DEMUX, MSGL_ERR, "VIVO: Not support audio codec (%d)\n",
 656                         priv->audio_codec);
 657                     free_sh_audio(demuxer, 1);
 658                     goto nosound;
 659                 }
 660
 661                 // Emulate WAVEFORMATEX struct:
 662                 sh->wf=malloc(sizeof(WAVEFORMATEX));
 663                 memset(sh->wf,0,sizeof(WAVEFORMATEX));
 664                 sh->wf->wFormatTag=sh->format;
 665                 sh->wf->nChannels=1; /* 1 channels for both Siren and G.723 */
 666
 667                 /* Set bits per sample */
 668                 if (priv->audio_codec == VIVO_AUDIO_SIREN)
 669                     sh->wf->wBitsPerSample = 16;
 670                 else
 671                 if (priv->audio_codec == VIVO_AUDIO_G723)
 672                     sh->wf->wBitsPerSample = 8;
 673
 674                 /* Set sampling rate */
 675                 if (priv->audio_samplerate) /* got from header */
 676                     sh->wf->nSamplesPerSec = priv->audio_samplerate;
 677                 else
 678                 {
 679                     if (priv->audio_codec == VIVO_AUDIO_SIREN)
 680                         sh->wf->nSamplesPerSec = 16000;
 681                     if (priv->audio_codec == VIVO_AUDIO_G723)
 682                         sh->wf->nSamplesPerSec = 8000;
 683                 }
 684                 if (vivo_param_samplerate != -1)
 685                     sh->wf->nSamplesPerSec = vivo_param_samplerate;
 686
 687                 /* Set audio bitrate */
 688                 if (priv->audio_bitrate) /* got from header */
 689                     sh->wf->nAvgBytesPerSec = priv->audio_bitrate;
 690                 else
 691                 {
 692                     if (priv->audio_codec == VIVO_AUDIO_SIREN)
 693                         sh->wf->nAvgBytesPerSec = 2000;
 694                     if (priv->audio_codec == VIVO_AUDIO_G723)
 695                         sh->wf->nAvgBytesPerSec = 800;
 696                 }
 697                 if (vivo_param_abitrate != -1)
 698                     sh->wf->nAvgBytesPerSec = vivo_param_abitrate;
 699                 audio_rate=sh->wf->nAvgBytesPerSec;
 700
 701                 if (!priv->audio_bytesperblock)
 702                 {
 703                     if (priv->audio_codec == VIVO_AUDIO_SIREN)
 704                         sh->wf->nBlockAlign = 40;
 705                     if (priv->audio_codec == VIVO_AUDIO_G723)
 706                         sh->wf->nBlockAlign = 24;
 707                 }
 708                 else
 709                     sh->wf->nBlockAlign = priv->audio_bytesperblock;
 710                 if (vivo_param_bytesperblock != -1)
 711                     sh->wf->nBlockAlign = vivo_param_bytesperblock;
 712
 713 /*sound_ok:*/
 714                 /* insert as stream */
 715                 demuxer->audio->sh=sh;
 716                 sh->ds=demuxer->audio;
 717                 demuxer->audio->id=1;
 718 nosound:
 719                 return demuxer;
 720 }
 721 }
 722     return demuxer;
 723 }
 724
 725 static void demux_close_vivo(demuxer_t *demuxer)
 726 {
 727     vivo_priv_t* priv=demuxer->priv;
 728
 729     if (priv) {
 730         if (priv->title)
 731             free(priv->title);
 732         if (priv->author)
 733             free(priv->author);
 734         if (priv->copyright)
 735             free(priv->copyright);
 736         if (priv->producer)
 737            free(priv->producer);
 738         free(priv);
 739     }
 740     return;
 741 }
 742
 743
 744 const demuxer_desc_t demuxer_desc_vivo = {
 745   "Vivo demuxer",
 746   "vivo",
 747   "VIVO",
 748   "A'rpi, Alex Beregszasi",
 749   "",
 750   DEMUXER_TYPE_VIVO,
 751   0, // unsafe autodetect
 752   vivo_check_file,
 753   demux_vivo_fill_buffer,
 754   demux_open_vivo,
 755   demux_close_vivo,
 756   NULL,
 757   NULL
 758 };