← Back to branch summary

~ubuntu-branches/debian/sid/mplayer/sid

« back to all changes in this revision

Viewing changes to libmpdemux/demux_ogg.c

  • Committer: Bazaar Package Importer
  • Author(s): A Mennucc1
  • Date: 2009-03-23 10:05:45 UTC
  • mfrom: (4.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20090323100545-x8h79obawnnte7kk
Tags: 1.0~rc2+svn20090303-5
debian/control : move docbook-xml,docbook-xsl,xsltproc from 
Build-Depends-Indep to Build-Depends, since they are needed to run
configure

Show diffs side-by-side

added added

removed removed

Lines of Context:
libmpdemux/demux_ogg.c
19
19
#define FOURCC_SPEEX  mmioFOURCC('s', 'p', 'x', ' ')
20
20
#define FOURCC_THEORA mmioFOURCC('t', 'h', 'e', 'o')
21
21
 
22
 
#ifdef TREMOR
 
22
#ifdef CONFIG_TREMOR
23
23
#include <tremor/ogg.h>
24
24
#include <tremor/ivorbiscodec.h>
25
25
#else
27
27
#include <vorbis/codec.h>
28
28
#endif
29
29
 
30
 
#ifdef HAVE_OGGTHEORA
 
30
#ifdef CONFIG_OGGTHEORA
31
31
#include <theora/theora.h>
32
 
extern int _ilog (unsigned int); /* defined in many places in theora/lib/ */
 
32
int _ilog (unsigned int); /* defined in many places in theora/lib/ */
33
33
#endif
34
34
 
35
35
#define BLOCK_SIZE 4096
38
38
 * without using theora_granule_time with the theora_state of the stream.
39
39
 * This is duplicated in `vd_theora.c'; put this in a common header?
40
40
 */
41
 
#ifdef HAVE_OGGTHEORA
 
41
#ifdef CONFIG_OGGTHEORA
42
42
typedef struct theora_struct_st {
43
43
    theora_state st;
44
44
    theora_comment cc;
99
99
  float samplerate; /// granulpos 2 time
100
100
  int64_t lastpos;
101
101
  int32_t lastsize;
 
102
  int keyframe_frequency_force;
102
103
 
103
104
  // Logical stream state
104
105
  ogg_stream_state stream;
111
112
  int id;
112
113
 
113
114
  vorbis_info      vi;
114
 
  int vi_inited;
 
115
  int vi_initialized;
115
116
 
116
117
  void *ogg_d;
117
118
} ogg_stream_t;
157
158
static subtitle ogg_sub;
158
159
//FILE* subout;
159
160
 
160
 
#define get_uint16(b) AV_RL16(b)
161
 
#define get_uint32(b) AV_RL32(b)
162
 
#define get_uint64(b) AV_RL64(b)
163
 
 
164
161
void demux_ogg_add_sub (ogg_stream_t* os,ogg_packet* pack) {
165
162
  int lcv;
166
163
  char *packet = pack->packet;
186
183
      duration <<= 8;
187
184
      duration |= (unsigned char)packet[i];
188
185
    }
189
 
    if ((hdrlen > 0) && (duration > 0)) {
 
186
    if (hdrlen > 0 && duration > 0) {
190
187
      float pts;
191
188
      if(pack->granulepos == -1)
192
189
        pack->granulepos = os->lastpos + os->lastsize;
199
196
 
200
197
  mp_msg(MSGT_DEMUX,MSGL_DBG2,"Ogg sub lines: %d  first: '%s'\n",
201
198
      ogg_sub.lines, ogg_sub.text[0]);
202
 
#ifdef USE_ICONV
 
199
#ifdef CONFIG_ICONV
203
200
  subcp_recode(&ogg_sub);
204
201
#endif
205
202
  vo_sub = &ogg_sub;
240
237
 
241
238
}
242
239
 
243
 
static unsigned char* demux_ogg_read_packet(ogg_stream_t* os,ogg_packet* pack,void *context,float* pts,int* flags, int samplesize) {
 
240
static unsigned char* demux_ogg_read_packet(ogg_stream_t* os,ogg_packet* pack,float* pts,int* flags, int samplesize) {
244
241
  unsigned char* data = pack->packet;
245
242
 
246
243
  *pts = 0;
249
246
  if(os->vorbis) {
250
247
    if(*pack->packet & PACKET_TYPE_HEADER)
251
248
      os->hdr_packets++;
252
 
    else if (os->vi_inited)
 
249
    else if (os->vi_initialized)
253
250
    {
254
251
       vorbis_info *vi;
255
252
       int32_t blocksize;
269
266
    }
270
267
  } else if (os->speex) {
271
268
    // whole packet (default)
272
 
# ifdef HAVE_OGGTHEORA
 
269
# ifdef CONFIG_OGGTHEORA
273
270
  } else if (os->theora) {
274
271
     /* we pass complete packets to theora, mustn't strip the header! */
275
272
     os->lastsize = 1;
276
273
     
277
 
     /* header packets beginn on 1-bit: thus check (*data&0x80).  We don't
 
274
     /* header packets begin on 1-bit: thus check (*data&0x80).  We don't
278
275
        have theora_state st, until all header packets were passed to the
279
276
        decoder. */
280
 
     if (context != NULL && !(*data&0x80))
 
277
     if (!(*data&0x80))
281
278
     {
282
 
        theora_info *thi = ((theora_struct_t*)context)->st.i;
283
 
        int keyframe_granule_shift=_ilog(thi->keyframe_frequency_force-1);
 
279
        int keyframe_granule_shift=_ilog(os->keyframe_frequency_force-1);
284
280
        int64_t iframemask = (1 << keyframe_granule_shift) - 1;
285
281
 
286
282
        if (pack->granulepos >= 0)
287
283
        {
288
284
           os->lastpos = pack->granulepos >> keyframe_granule_shift;
289
285
           os->lastpos += pack->granulepos & iframemask;
290
 
           *flags = ((pack->granulepos & iframemask) == 0);
 
286
           *flags = (pack->granulepos & iframemask) == 0;
291
287
        }
292
288
        else
293
289
        {
296
292
        pack->granulepos = os->lastpos;
297
293
        *pts = (double)os->lastpos / (double)os->samplerate;
298
294
     }
299
 
#endif /* HAVE_OGGTHEORA */
 
295
#endif /* CONFIG_OGGTHEORA */
300
296
  } else if (os->flac) {
301
297
     /* we pass complete packets to flac, mustn't strip the header! */
302
298
     if (os->flac == 2 && pack->packet[0] != 0xff)
330
326
}
331
327
 
332
328
// check if clang has substring from comma separated langlist
333
 
static int demux_ogg_check_lang(const char *clang, char *langlist)
 
329
static int demux_ogg_check_lang(const char *clang, const char *langlist)
334
330
{
335
 
  char *c;
 
331
  const char *c;
336
332
 
337
333
  if (!langlist || !*langlist)
338
334
    return 0;
355
351
  const char *hdr, *val;
356
352
  char **cmt = vc->user_comments;
357
353
  int index, i;
358
 
  ogg_demuxer_t *ogg_d = (ogg_demuxer_t *)d->priv;
359
 
  struct table {
 
354
  ogg_demuxer_t *ogg_d = d->priv;
 
355
  static const struct table {
360
356
    const char *ogg;
361
357
    const char *mp;
362
358
  } table[] = {
387
383
      // copy this language name into the array
388
384
      index = demux_ogg_sub_reverse_id(d, id);
389
385
      if (index >= 0) {
 
386
        sh_sub_t* sh;
390
387
        // in case of malicious files with more than one lang per track:
391
388
        if (ogg_d->text_langs[index]) free(ogg_d->text_langs[index]);
392
389
        ogg_d->text_langs[index] = strdup(val);
 
390
        sh = d->s_streams[index];
 
391
        if (sh && sh->lang) free(sh->lang);
 
392
        if (sh) sh->lang = strdup(val);
393
393
      }
394
394
      // check for -slang if subs are uninitialized yet
395
395
      if (os->text && d->sub->id < 0 && demux_ogg_check_lang(val, dvdsub_lang))
427
427
  unsigned char* data;
428
428
  float pts = 0;
429
429
  int flags = 0;
430
 
  void *context = NULL;
431
430
  int samplesize = 1;
432
431
 
433
432
  // If packet is an comment header then we try to get comments at first
460
459
  // (PACKET_TYPE_HEADER bit doesn't even exist for theora ?!)
461
460
  // We jump nothing for FLAC. Ain't this great? Packet contents have to be
462
461
  // handled differently for each and every stream type. The joy! The joy!
463
 
  if(!os->flac && ((*pack->packet & PACKET_TYPE_HEADER) && 
464
 
     (ds != d->audio || ( ((sh_audio_t*)ds->sh)->format != FOURCC_VORBIS || os->hdr_packets >= NUM_VORBIS_HDR_PACKETS ) ) &&
465
 
     (ds != d->video || (((sh_video_t*)ds->sh)->format != FOURCC_THEORA))))
 
462
  if(!os->flac && (*pack->packet & PACKET_TYPE_HEADER) && 
 
463
     (ds != d->audio || ((sh_audio_t*)ds->sh)->format != FOURCC_VORBIS || os->hdr_packets >= NUM_VORBIS_HDR_PACKETS ) &&
 
464
     (ds != d->video || (((sh_video_t*)ds->sh)->format != FOURCC_THEORA)))
466
465
    return 0;
467
466
 
468
467
  // For vorbis packet the packet is the data, for other codec we must jump
469
468
  // the header
470
469
  if(ds == d->audio && ((sh_audio_t*)ds->sh)->format == FOURCC_VORBIS) {
471
 
     context = ((sh_audio_t *)ds->sh)->context;
472
470
     samplesize = ((sh_audio_t *)ds->sh)->samplesize;
473
471
  }
474
 
  if (ds == d->video && ((sh_audio_t*)ds->sh)->format == FOURCC_THEORA)
475
 
     context = ((sh_video_t *)ds->sh)->context;
476
 
  data = demux_ogg_read_packet(os,pack,context,&pts,&flags,samplesize);
 
472
  data = demux_ogg_read_packet(os,pack,&pts,&flags,samplesize);
477
473
  if (!data)
478
474
    return 0;
479
475
 
504
500
  ogg_stream_t* os;
505
501
  ogg_packet op;
506
502
  int np,sid,p,samplesize=1;
507
 
  void *context = NULL;
508
503
  off_t pos, last_pos;
509
504
  pos = last_pos = demuxer->movi_start;
510
505
 
520
515
  // Get the serial number of the stream we use
521
516
  if(demuxer->video->id >= 0) {
522
517
    sid = demuxer->video->id;
523
 
    /* demux_ogg_read_packet needs decoder context for Theora streams */
524
 
    if (((sh_video_t*)demuxer->video->sh)->format == FOURCC_THEORA)
525
 
      context = ((sh_video_t*)demuxer->video->sh)->context;
526
518
  }
527
519
  else if(demuxer->audio->id >= 0) {
528
520
    sid = demuxer->audio->id;
529
 
    /* demux_ogg_read_packet needs decoder context for Vorbis streams */
530
521
    if(((sh_audio_t*)demuxer->audio->sh)->format == FOURCC_VORBIS) {
531
 
      context = ((sh_audio_t*)demuxer->audio->sh)->context;
532
522
      samplesize = ((sh_audio_t*)demuxer->audio->sh)->samplesize;
533
523
    }
534
524
  }
566
556
    while(ogg_stream_packetout(oss,&op) == 1) {
567
557
      float pts;
568
558
      int flags;
569
 
      demux_ogg_read_packet(os,&op,context,&pts,&flags,samplesize);
 
559
      demux_ogg_read_packet(os,&op,&pts,&flags,samplesize);
570
560
      if(op.granulepos >= 0) ogg_d->final_granulepos = op.granulepos;
571
561
      if(index_mode == 2 && (flags || (os->vorbis && op.granulepos >= 0))) {
572
562
        if (ogg_d->num_syncpoint > SIZE_MAX / sizeof(ogg_syncpoint_t) - 1) break;
617
607
  
618
608
}
619
609
 
620
 
extern void print_wave_header(WAVEFORMATEX *h, int verbose_level);
621
 
extern void print_video_header(BITMAPINFOHEADER *h, int verbose_level);
 
610
void print_wave_header(WAVEFORMATEX *h, int verbose_level);
 
611
void print_video_header(BITMAPINFOHEADER *h, int verbose_level);
622
612
 
623
613
/* defined in demux_mov.c */
624
 
extern unsigned int store_ughvlc(unsigned char *s, unsigned int v);
 
614
unsigned int store_ughvlc(unsigned char *s, unsigned int v);
625
615
 
626
616
/** \brief Change the current subtitle stream and return its ID.
627
617
 
633
623
  track.
634
624
*/
635
625
int demux_ogg_sub_id(demuxer_t *demuxer, int index) {
636
 
  ogg_demuxer_t *ogg_d = (ogg_demuxer_t *)demuxer->priv;
 
626
  ogg_demuxer_t *ogg_d = demuxer->priv;
637
627
  return (index < 0) ? index : (index >= ogg_d->n_text) ? -1 : ogg_d->text_ids[index];
638
628
}
639
629
 
642
632
 *  \param id The ogg track number of the subtitle track.
643
633
 */
644
634
static int demux_ogg_sub_reverse_id(demuxer_t *demuxer, int id) {
645
 
  ogg_demuxer_t *ogg_d = (ogg_demuxer_t *)demuxer->priv;
 
635
  ogg_demuxer_t *ogg_d = demuxer->priv;
646
636
  int i;
647
637
  for (i = 0; i < ogg_d->n_text; i++)
648
638
    if (ogg_d->text_ids[i] == id) return i;
649
639
  return -1;
650
640
}
651
641
 
652
 
/** \brief Lookup the subtitle language by the subtitle number.  Returns NULL on out-of-bounds input.
653
 
 *  \param demuxer The demuxer about whose subtitles we are inquiring.
654
 
 *  \param index The subtitle number.
655
 
 */
656
 
char *demux_ogg_sub_lang(demuxer_t *demuxer, int index) {
657
 
  ogg_demuxer_t *ogg_d = (ogg_demuxer_t *)demuxer->priv;
658
 
  return (index < 0) ? NULL : (index >= ogg_d->n_text) ? NULL : ogg_d->text_langs[index];
659
 
}
660
 
 
661
642
static void demux_close_ogg(demuxer_t* demuxer);
662
643
 
663
644
static void fixup_vorbis_wf(sh_audio_t *sh, ogg_demuxer_t *od)
686
667
    memcpy(buf[i], op[i].packet, op[i].bytes);
687
668
 
688
669
    op[i].b_o_s = (i==0);
689
 
    ris = vorbis_synthesis_headerin(&(os->vi),&vc,&(op[i]));
 
670
    ris = vorbis_synthesis_headerin(&os->vi,&vc,&op[i]);
690
671
    if(ris < 0) {
691
672
      init_error = 1;
692
673
      mp_msg(MSGT_DECAUDIO,MSGL_ERR,"DEMUX_OGG: header n. %d broken! len=%ld, code: %d\n", i, op[i].bytes, ris);
694
675
  }
695
676
  vorbis_comment_clear(&vc);
696
677
  if(!init_error)
697
 
    os->vi_inited = 1;
 
678
    os->vi_initialized = 1;
698
679
 
699
680
  len = op[0].bytes + op[1].bytes + op[2].bytes;
700
681
  sh->wf = calloc(1, sizeof(WAVEFORMATEX) + len + len/255 + 64);
713
694
  }
714
695
  sh->wf->cbSize = offset;
715
696
  mp_msg(MSGT_DEMUX,MSGL_V, "demux_ogg, extradata size: %d\n", sh->wf->cbSize);
716
 
  sh->wf = (WAVEFORMATEX*)realloc(sh->wf, sizeof(WAVEFORMATEX) + sh->wf->cbSize);
 
697
  sh->wf = realloc(sh->wf, sizeof(WAVEFORMATEX) + sh->wf->cbSize);
717
698
 
718
699
  if(op[0].bytes >= 29) {
719
700
    unsigned int br;
720
701
    int nombr, minbr, maxbr;
721
702
    ptr = buf[0];
722
703
    sh->channels = ptr[11];
723
 
    sh->samplerate = sh->wf->nSamplesPerSec = get_uint32(&ptr[12]);
724
 
    maxbr = get_uint32(&ptr[16]);  //max
725
 
    nombr = get_uint32(&ptr[20]);  //nominal
726
 
    minbr = get_uint32(&ptr[24]);  //minimum
 
704
    sh->samplerate = sh->wf->nSamplesPerSec = AV_RL32(&ptr[12]);
 
705
    maxbr = AV_RL32(&ptr[16]);  //max
 
706
    nombr = AV_RL32(&ptr[20]);  //nominal
 
707
    minbr = AV_RL32(&ptr[24]);  //minimum
727
708
 
728
709
    if(maxbr == -1)
729
710
        maxbr = 0;
764
745
  sh_audio_t* sh_a;
765
746
  sh_video_t* sh_v;
766
747
 
767
 
#ifdef USE_ICONV
 
748
#ifdef CONFIG_ICONV
768
749
  subcp_open(NULL);
769
750
#endif
770
751
 
800
781
    ogg_d->last_size = np;
801
782
    // We got one page now
802
783
 
803
 
    if( ! ogg_page_bos(page) ) { // It's not a begining page
 
784
    if( ! ogg_page_bos(page) ) { // It's not a beginning page
804
785
      // Header parsing end here, we need to get the page otherwise it will be lost
805
786
      int id = demux_ogg_get_page_stream(ogg_d,NULL);
806
787
      if(id >= 0)
811
792
    }
812
793
 
813
794
    /// Init  the data structure needed for a logical stream
814
 
    ogg_d->subs = (ogg_stream_t*)realloc(ogg_d->subs,(ogg_d->num_sub+1)*sizeof(ogg_stream_t));
 
795
    ogg_d->subs = realloc_struct(ogg_d->subs,ogg_d->num_sub+1,sizeof(ogg_stream_t));
815
796
    memset(&ogg_d->subs[ogg_d->num_sub],0,sizeof(ogg_stream_t));
816
797
    /// Get the stream serial number
817
798
    s_no = ogg_page_serialno(page);
840
821
      sh_a = new_sh_audio_aid(demuxer, ogg_d->num_sub, n_audio);
841
822
      sh_a->wf = calloc(1, sizeof(WAVEFORMATEX) + pack.bytes);
842
823
      sh_a->format = FOURCC_SPEEX;
843
 
      sh_a->samplerate = sh_a->wf->nSamplesPerSec = get_uint32(&pack.packet[36]);
844
 
      sh_a->channels = sh_a->wf->nChannels = get_uint32(&pack.packet[48]);
 
824
      sh_a->samplerate = sh_a->wf->nSamplesPerSec = AV_RL32(&pack.packet[36]);
 
825
      sh_a->channels = sh_a->wf->nChannels = AV_RL32(&pack.packet[48]);
845
826
      sh_a->wf->wFormatTag = sh_a->format;
846
 
      sh_a->wf->nAvgBytesPerSec = get_uint32(&pack.packet[52]);
 
827
      sh_a->wf->nAvgBytesPerSec = AV_RL32(&pack.packet[52]);
847
828
      sh_a->wf->nBlockAlign = 0;
848
829
      sh_a->wf->wBitsPerSample = 16;
849
830
      sh_a->samplesize = 2;
857
838
      mp_msg(MSGT_DEMUX,MSGL_INFO,"[Ogg] stream %d: audio (Speex), -aid %d\n",ogg_d->num_sub,n_audio-1);
858
839
 
859
840
      // check for Theora
860
 
#   ifdef HAVE_OGGTHEORA
 
841
#   ifdef CONFIG_OGGTHEORA
861
842
    } else if (pack.bytes >= 7 && !strncmp (&pack.packet[1], "theora", 6)) {
862
843
        int errorCode = 0;
863
844
        theora_info inf;
874
855
        {
875
856
            sh_v = new_sh_video_vid(demuxer,ogg_d->num_sub, n_video);
876
857
 
877
 
            sh_v->context = NULL;
878
858
            sh_v->bih = calloc(1,sizeof(BITMAPINFOHEADER));
879
859
            sh_v->bih->biSize=sizeof(BITMAPINFOHEADER);
880
860
            sh_v->bih->biCompression= sh_v->format = FOURCC_THEORA;
890
870
                                      sh_v->bih->biWidth*sh_v->bih->biHeight);
891
871
            ogg_d->subs[ogg_d->num_sub].samplerate = sh_v->fps;
892
872
            ogg_d->subs[ogg_d->num_sub].theora = 1;
 
873
            ogg_d->subs[ogg_d->num_sub].keyframe_frequency_force = inf.keyframe_frequency_force;
893
874
            ogg_d->subs[ogg_d->num_sub].id = n_video;
894
875
            n_video++;
895
876
            mp_msg(MSGT_DEMUX,MSGL_INFO,
903
884
        }
904
885
        theora_comment_clear(&cc);
905
886
        theora_info_clear(&inf);
906
 
#   endif /* HAVE_OGGTHEORA */
 
887
#   endif /* CONFIG_OGGTHEORA */
907
888
    } else if (pack.bytes >= 4 && !strncmp (&pack.packet[0], "fLaC", 4)) {
908
889
        sh_a = new_sh_audio_aid(demuxer,ogg_d->num_sub, n_audio);
909
890
        sh_a->format =  mmioFOURCC('f', 'L', 'a', 'C');
928
909
    } else if(pack.bytes >= 142 && ! strncmp(&pack.packet[1],"Direct Show Samples embedded in Ogg",35) ) {
929
910
 
930
911
       // Old video header
931
 
      if(get_uint32 (pack.packet+96) == 0x05589f80 && pack.bytes >= 184) {
 
912
      if(AV_RL32(pack.packet+96) == 0x05589f80 && pack.bytes >= 184) {
932
913
        sh_v = new_sh_video_vid(demuxer,ogg_d->num_sub, n_video);
933
914
        sh_v->bih = calloc(1,sizeof(BITMAPINFOHEADER));
934
915
        sh_v->bih->biSize=sizeof(BITMAPINFOHEADER);
935
916
        sh_v->bih->biCompression=
936
917
        sh_v->format = mmioFOURCC(pack.packet[68],pack.packet[69],
937
918
                                pack.packet[70],pack.packet[71]);
938
 
        sh_v->frametime = get_uint64(pack.packet+164)*0.0000001;
 
919
        sh_v->frametime = AV_RL64(pack.packet+164)*0.0000001;
939
920
        sh_v->fps = 1/sh_v->frametime;
940
 
        sh_v->disp_w = sh_v->bih->biWidth = get_uint32(pack.packet+176);
941
 
        sh_v->disp_h = sh_v->bih->biHeight = get_uint32(pack.packet+180);
942
 
        sh_v->bih->biBitCount = get_uint16(pack.packet+182);
 
921
        sh_v->disp_w = sh_v->bih->biWidth = AV_RL32(pack.packet+176);
 
922
        sh_v->disp_h = sh_v->bih->biHeight = AV_RL32(pack.packet+180);
 
923
        sh_v->bih->biBitCount = AV_RL16(pack.packet+182);
943
924
        if(!sh_v->bih->biBitCount) sh_v->bih->biBitCount=24; // hack, FIXME
944
925
        sh_v->bih->biPlanes=1;
945
926
        sh_v->bih->biSizeImage=(sh_v->bih->biBitCount>>3)*sh_v->bih->biWidth*sh_v->bih->biHeight;
951
932
               ogg_d->num_sub,pack.packet[68],pack.packet[69],pack.packet[70],pack.packet[71],n_video-1);
952
933
        if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_video_header(sh_v->bih,MSGL_V);
953
934
        // Old audio header
954
 
      } else if(get_uint32(pack.packet+96) == 0x05589F81) {
 
935
      } else if(AV_RL32(pack.packet+96) == 0x05589F81) {
955
936
        unsigned int extra_size;
956
937
        sh_a = new_sh_audio_aid(demuxer,ogg_d->num_sub, n_audio);
957
 
        extra_size = get_uint16(pack.packet+140);
 
938
        extra_size = AV_RL16(pack.packet+140);
958
939
        sh_a->wf = calloc(1,sizeof(WAVEFORMATEX)+extra_size);
959
 
        sh_a->format = sh_a->wf->wFormatTag = get_uint16(pack.packet+124);
960
 
        sh_a->channels = sh_a->wf->nChannels = get_uint16(pack.packet+126);
961
 
        sh_a->samplerate = sh_a->wf->nSamplesPerSec = get_uint32(pack.packet+128);
962
 
        sh_a->wf->nAvgBytesPerSec = get_uint32(pack.packet+132);
963
 
        sh_a->wf->nBlockAlign = get_uint16(pack.packet+136);
964
 
        sh_a->wf->wBitsPerSample = get_uint16(pack.packet+138);
 
940
        sh_a->format = sh_a->wf->wFormatTag = AV_RL16(pack.packet+124);
 
941
        sh_a->channels = sh_a->wf->nChannels = AV_RL16(pack.packet+126);
 
942
        sh_a->samplerate = sh_a->wf->nSamplesPerSec = AV_RL32(pack.packet+128);
 
943
        sh_a->wf->nAvgBytesPerSec = AV_RL32(pack.packet+132);
 
944
        sh_a->wf->nBlockAlign = AV_RL16(pack.packet+136);
 
945
        sh_a->wf->wBitsPerSample = AV_RL16(pack.packet+138);
965
946
        sh_a->samplesize = (sh_a->wf->wBitsPerSample+7)/8;
966
947
        sh_a->wf->cbSize = extra_size;
967
948
        if(extra_size > 0)
987
968
        sh_v->bih->biCompression=
988
969
        sh_v->format = mmioFOURCC(st->subtype[0],st->subtype[1],
989
970
                                  st->subtype[2],st->subtype[3]);
990
 
        sh_v->frametime = get_uint64(&st->time_unit)*0.0000001;
 
971
        sh_v->frametime = AV_RL64(&st->time_unit)*0.0000001;
991
972
        sh_v->fps = 1.0/sh_v->frametime;
992
 
        sh_v->bih->biBitCount = get_uint16(&st->bits_per_sample);
993
 
        sh_v->disp_w = sh_v->bih->biWidth = get_uint32(&st->sh.video.width);
994
 
        sh_v->disp_h = sh_v->bih->biHeight = get_uint32(&st->sh.video.height);
 
973
        sh_v->bih->biBitCount = AV_RL16(&st->bits_per_sample);
 
974
        sh_v->disp_w = sh_v->bih->biWidth = AV_RL32(&st->sh.video.width);
 
975
        sh_v->disp_h = sh_v->bih->biHeight = AV_RL32(&st->sh.video.height);
995
976
        if(!sh_v->bih->biBitCount) sh_v->bih->biBitCount=24; // hack, FIXME
996
977
        sh_v->bih->biPlanes=1;
997
978
        sh_v->bih->biSizeImage=(sh_v->bih->biBitCount>>3)*sh_v->bih->biWidth*sh_v->bih->biHeight;
1005
986
        /// New audio header
1006
987
      } else if(strncmp(st->streamtype,"audio",5) == 0) {
1007
988
        char buffer[5];
1008
 
        unsigned int extra_size = get_uint32 (&st->size) - sizeof(stream_header);
 
989
        unsigned int extra_size = AV_RL32(&st->size) - sizeof(stream_header);
1009
990
        unsigned int extra_offset = 0;
1010
991
 
1011
992
        memcpy(buffer,st->subtype,4);
1024
1005
        sh_a = new_sh_audio_aid(demuxer,ogg_d->num_sub, n_audio);
1025
1006
        sh_a->wf = calloc(1,sizeof(WAVEFORMATEX)+extra_size);
1026
1007
        sh_a->format =  sh_a->wf->wFormatTag = strtol(buffer, NULL, 16);
1027
 
        sh_a->channels = sh_a->wf->nChannels = get_uint16(&st->sh.audio.channels);
1028
 
        sh_a->samplerate = sh_a->wf->nSamplesPerSec = get_uint64(&st->samples_per_unit);
1029
 
        sh_a->wf->nAvgBytesPerSec = get_uint32(&st->sh.audio.avgbytespersec);
1030
 
        sh_a->wf->nBlockAlign = get_uint16(&st->sh.audio.blockalign);
1031
 
        sh_a->wf->wBitsPerSample = get_uint16(&st->bits_per_sample);
 
1008
        sh_a->channels = sh_a->wf->nChannels = AV_RL16(&st->sh.audio.channels);
 
1009
        sh_a->samplerate = sh_a->wf->nSamplesPerSec = AV_RL64(&st->samples_per_unit);
 
1010
        sh_a->wf->nAvgBytesPerSec = AV_RL32(&st->sh.audio.avgbytespersec);
 
1011
        sh_a->wf->nBlockAlign = AV_RL16(&st->sh.audio.blockalign);
 
1012
        sh_a->wf->wBitsPerSample = AV_RL16(&st->bits_per_sample);
1032
1013
        sh_a->samplesize = (sh_a->wf->wBitsPerSample+7)/8;
1033
1014
        sh_a->wf->cbSize = extra_size;
1034
1015
        if(extra_size)
1043
1024
        /// Check for text (subtitles) header
1044
1025
      } else if (strncmp(st->streamtype, "text", 4) == 0) {
1045
1026
          mp_msg(MSGT_DEMUX, MSGL_INFO, "[Ogg] stream %d: subtitles (SRT-like text subtitles), -sid %d\n", ogg_d->num_sub, ogg_d->n_text);
1046
 
          ogg_d->subs[ogg_d->num_sub].samplerate= get_uint64(&st->time_unit)/10;
 
1027
          ogg_d->subs[ogg_d->num_sub].samplerate= AV_RL64(&st->time_unit)/10;
1047
1028
          ogg_d->subs[ogg_d->num_sub].text = 1;
1048
1029
          ogg_d->subs[ogg_d->num_sub].id = ogg_d->n_text;
1049
1030
          if (demuxer->sub->id == ogg_d->n_text)
1050
1031
            text_id = ogg_d->num_sub;
1051
1032
          new_sh_sub(demuxer, ogg_d->n_text);
1052
1033
          ogg_d->n_text++;
1053
 
          ogg_d->text_ids = (int *)realloc(ogg_d->text_ids, sizeof(int) * ogg_d->n_text);
 
1034
          ogg_d->text_ids = realloc_struct(ogg_d->text_ids, ogg_d->n_text, sizeof(int));
1054
1035
          ogg_d->text_ids[ogg_d->n_text - 1] = ogg_d->num_sub;
1055
 
          ogg_d->text_langs = (char **)realloc(ogg_d->text_langs, sizeof(char *) * ogg_d->n_text);
 
1036
          ogg_d->text_langs = realloc_struct(ogg_d->text_langs, ogg_d->n_text, sizeof(char *));
1056
1037
          ogg_d->text_langs[ogg_d->n_text - 1] = NULL;
1057
1038
        //// Unknown header type
1058
1039
      } else
1070
1051
//        if(sh_a->wf) print_wave_header(sh_a->wf,MSGL_INFO);
1071
1052
        }
1072
1053
        /// Is it the stream we want
1073
 
        if(demuxer->audio->id == (n_audio - 1)) {
 
1054
        if(demuxer->audio->id == n_audio - 1) {
1074
1055
          demuxer->audio->sh = sh_a;
1075
1056
          sh_a->ds = demuxer->audio;
1076
1057
          ds = demuxer->audio;
1083
1064
          demuxer->video->id = n_video - 1;
1084
1065
//        if(sh_v->bih) print_video_header(sh_v->bih,MSGL_INFO);
1085
1066
        }
1086
 
        if(demuxer->video->id == (n_video - 1)) {
 
1067
        if(demuxer->video->id == n_video - 1) {
1087
1068
          demuxer->video->sh = sh_v;
1088
1069
          sh_v->ds = demuxer->video;
1089
1070
          ds = demuxer->video;
1105
1086
    goto err_out;
1106
1087
  }
1107
1088
 
1108
 
  if(!n_video || (video_id < 0))
 
1089
  if(!n_video || video_id < 0)
1109
1090
    demuxer->video->id = -2;
1110
1091
  else
1111
1092
    demuxer->video->id = video_id;
1112
 
  if(!n_audio || (audio_id < 0))
 
1093
  if(!n_audio || audio_id < 0)
1113
1094
    demuxer->audio->id = -2;
1114
1095
  else
1115
1096
    demuxer->audio->id = audio_id;
1242
1223
  demux_packet_t *dp;
1243
1224
  sh_audio_t *sh_audio = demuxer->audio->sh;
1244
1225
  int np;
 
1226
  uint8_t *extradata = sh_audio->wf + 1;
 
1227
  int i;
1245
1228
  unsigned char *p = NULL,*buf;
1246
1229
  int plen;
1247
1230
 
1248
 
  /// Check that the cbSize is enouth big for the following reads
1249
 
  if(sh_audio->wf->cbSize < 22+3*sizeof(uint32_t)) {
 
1231
  /// Check that the cbSize is big enough for the following reads
 
1232
  if(sh_audio->wf->cbSize < 22+3*4) {
1250
1233
    mp_msg(MSGT_DEMUX,MSGL_ERR,"AVI Ogg : Initial audio header is too small !!!!!\n");
1251
1234
    goto fallback;
1252
1235
  }
1253
1236
  /// Get the size of the 3 header packet
1254
 
  memcpy(hdrsizes, ((unsigned char*)sh_audio->wf)+22+sizeof(WAVEFORMATEX), 3*sizeof(uint32_t));
 
1237
  extradata += 22;
 
1238
  for (i = 0; i < 3; i++) {
 
1239
    hdrsizes[i] = AV_RL32(extradata);
 
1240
    extradata += 4;
 
1241
  }
1255
1242
//  printf("\n!!!!!! hdr sizes: %d %d %d   \n",hdrsizes[0],hdrsizes[1],hdrsizes[2]);
1256
1243
 
1257
1244
  /// Check the size
1258
 
  if(sh_audio->wf->cbSize < 22+3*sizeof(uint32_t)+hdrsizes[0]+hdrsizes[1] + hdrsizes[2]) {
 
1245
  if(sh_audio->wf->cbSize < 22+3*4+hdrsizes[0]+hdrsizes[1] + hdrsizes[2]) {
1259
1246
    mp_msg(MSGT_DEMUX,MSGL_ERR,"AVI Ogg : Audio header is too small !!!!!\n");
1260
1247
    goto fallback;
1261
1248
  }
1293
1280
  od = new_demuxer(s,DEMUXER_TYPE_OGG,0,-2,-2,NULL);
1294
1281
 
1295
1282
  /// Add the header packets in the ogg demuxer audio stream
1296
 
  // Initial header
1297
 
  dp = new_demux_packet(hdrsizes[0]);
1298
 
  memcpy(dp->buffer,((unsigned char*)sh_audio->wf)+22+sizeof(WAVEFORMATEX)+3*sizeof(uint32_t),hdrsizes[0]);
1299
 
  ds_add_packet(od->audio,dp);
1300
 
  /// Comments
1301
 
  dp = new_demux_packet(hdrsizes[1]);
1302
 
  memcpy(dp->buffer,((unsigned char*)sh_audio->wf)+22+sizeof(WAVEFORMATEX)+3*sizeof(uint32_t)+hdrsizes[0],hdrsizes[1]);
1303
 
  ds_add_packet(od->audio,dp);
1304
 
  /// Code book
1305
 
  dp = new_demux_packet(hdrsizes[2]);
1306
 
  memcpy(dp->buffer,((unsigned char*)sh_audio->wf)+22+sizeof(WAVEFORMATEX)+3*sizeof(uint32_t)+hdrsizes[0]+hdrsizes[1],hdrsizes[2]);
1307
 
  ds_add_packet(od->audio,dp);
 
1283
  for (i = 0; i < 3; i++) {
 
1284
    dp = new_demux_packet(hdrsizes[i]);
 
1285
    memcpy(dp->buffer,extradata,hdrsizes[i]);
 
1286
    ds_add_packet(od->audio,dp);
 
1287
    extradata += hdrsizes[i];
 
1288
  }
1308
1289
 
1309
1290
  // Finish setting up the ogg demuxer
1310
1291
  od->priv = ogg_d;
1314
1295
  od->audio->sh = sh_audio;
1315
1296
  sh_audio->ds = od->audio;
1316
1297
  sh_audio->format = FOURCC_VORBIS;
 
1298
  fixup_vorbis_wf(sh_audio, ogg_d);
1317
1299
 
1318
1300
  /// Return the joined demuxers
1319
1301
  return new_demuxers_demuxer(demuxer,od,demuxer);
1336
1318
  int i,sp,first,precision=1,do_seek=1;
1337
1319
  vorbis_info* vi = NULL;
1338
1320
  int64_t gp = 0, old_gp;
1339
 
  void *context = NULL;
1340
1321
  off_t pos, old_pos;
1341
1322
  int np;
1342
1323
  int is_gp_valid;
1347
1328
 
1348
1329
  if(demuxer->video->id >= 0) {
1349
1330
    ds = demuxer->video;
1350
 
    /* demux_ogg_read_packet needs decoder context for Theora streams */
1351
 
    if (((sh_video_t*)demuxer->video->sh)->format == FOURCC_THEORA)
1352
 
      context = ((sh_video_t*)demuxer->video->sh)->context;
1353
1331
    rate = ogg_d->subs[ds->id].samplerate;
1354
1332
  } else {
1355
1333
    ds = demuxer->audio;
1356
1334
    os = &ogg_d->subs[ds->id];
1357
 
    /* demux_ogg_read_packet needs decoder context for Vorbis streams */
1358
 
    if(((sh_audio_t*)demuxer->audio->sh)->format == FOURCC_VORBIS)
1359
 
      context = ((sh_audio_t*)demuxer->audio->sh)->context;
1360
1335
    vi = &(os->vi);
1361
1336
    rate = (float)vi->rate;
1362
1337
    samplesize = ((sh_audio_t*)ds->sh)->samplesize;
1369
1344
  old_pos = ogg_d->pos;
1370
1345
 
1371
1346
  //calculate the granulepos to seek to
1372
 
    gp = flags & 1 ? 0 : os->lastpos;
1373
 
  if(flags & 2) {
 
1347
    gp = flags & SEEK_ABSOLUTE ? 0 : os->lastpos;
 
1348
  if(flags & SEEK_FACTOR) {
1374
1349
    if (ogg_d->final_granulepos > 0)
1375
1350
      gp += ogg_d->final_granulepos * rel_seek_secs;
1376
1351
      else
1395
1370
    pos = ogg_d->syncpoints[sp].page_pos;
1396
1371
    precision = 0;
1397
1372
  } else {
1398
 
    pos = flags & 1 ? 0 : ogg_d->pos;
1399
 
    if(flags & 2)
 
1373
    pos = flags & SEEK_ABSOLUTE ? 0 : ogg_d->pos;
 
1374
    if(flags & SEEK_FACTOR)
1400
1375
      pos += (demuxer->movi_end - demuxer->movi_start) * rel_seek_secs;
1401
1376
    else {
1402
1377
      if (ogg_d->final_granulepos > 0) {
1463
1438
      }
1464
1439
      is_gp_valid = (op.granulepos >= 0);
1465
1440
      granulepos_orig=op.granulepos;
1466
 
      demux_ogg_read_packet(os,&op,context,&pts,&is_keyframe,samplesize);
 
1441
      demux_ogg_read_packet(os,&op,&pts,&is_keyframe,samplesize);
1467
1442
      if (precision && is_gp_valid) {
1468
1443
        precision--;
1469
1444
        if (abs(gp - op.granulepos) > rate && (op.granulepos != old_gp)) {
1470
1445
          //prepare another seek because we are off by more than 1s
1471
1446
          pos += (gp - op.granulepos) * (pos - old_pos) / (op.granulepos - old_gp);
1472
1447
          if (pos < 0) pos = 0;
1473
 
          if (pos < (demuxer->movi_end - demuxer->movi_start)) {
 
1448
          if (pos < demuxer->movi_end - demuxer->movi_start) {
1474
1449
            do_seek=1;
1475
1450
            break;
1476
1451
          }
1477
1452
        }
1478
1453
      }
1479
 
      if (is_gp_valid && (pos > 0) && (old_gp > gp)
1480
 
          && (2 * (old_gp - op.granulepos) < old_gp - gp)) {
 
1454
      if (is_gp_valid && pos > 0 && old_gp > gp
 
1455
          && 2 * (old_gp - op.granulepos) < old_gp - gp) {
1481
1456
        /* prepare another seek because looking for a syncpoint
1482
1457
           destroyed the backward search */
1483
1458
        pos = old_pos - 1.5 * (old_pos - pos);
1484
1459
        if (pos < 0) pos = 0;
1485
 
        if (pos < (demuxer->movi_end - demuxer->movi_start)) {
 
1460
        if (pos < demuxer->movi_end - demuxer->movi_start) {
1486
1461
          do_seek=1;
1487
1462
          break;
1488
1463
        }
1511
1486
  if(!ogg_d)
1512
1487
    return;
1513
1488
 
1514
 
#ifdef USE_ICONV
 
1489
#ifdef CONFIG_ICONV
1515
1490
  subcp_close();
1516
1491
#endif
1517
1492
 
1522
1497
    {
1523
1498
      os = &ogg_d->subs[i];
1524
1499
      ogg_stream_clear(&os->stream);
1525
 
      if(os->vi_inited)
 
1500
      if(os->vi_initialized)
1526
1501
        vorbis_info_clear(&os->vi);
1527
1502
    }
1528
1503
    free(ogg_d->subs);
1556
1531
    switch(cmd) {
1557
1532
        case DEMUXER_CTRL_GET_TIME_LENGTH:
1558
1533
            if (ogg_d->final_granulepos<=0) return DEMUXER_CTRL_DONTKNOW;
1559
 
            *((double *)arg)=(double)ogg_d->final_granulepos / rate;
 
1534
            *(double *)arg=(double)ogg_d->final_granulepos / rate;
1560
1535
            return DEMUXER_CTRL_GUESS;
1561
1536
 
1562
1537
        case DEMUXER_CTRL_GET_PERCENT_POS:
1563
1538
            if (ogg_d->final_granulepos<=0) return DEMUXER_CTRL_DONTKNOW;
1564
 
            *((int *)arg)=(int)( (os->lastpos*100) / ogg_d->final_granulepos);
 
1539
            *(int *)arg=(os->lastpos*100) / ogg_d->final_granulepos;
1565
1540
            return DEMUXER_CTRL_OK;
1566
1541
 
1567
1542
        default:
1571
1546
 
1572
1547
 
1573
1548
 
1574
 
demuxer_desc_t demuxer_desc_ogg = {
 
1549
const demuxer_desc_t demuxer_desc_ogg = {
1575
1550
  "Ogg demuxer",
1576
1551
  "ogg",
1577
1552
  "Ogg",