libmpdemux/demux_viv.c

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