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