Remeber the range table for the quant matricies from the setup header.
[theora.git] / lib / toplevel.c
1 /********************************************************************
2  *                                                                  *
3  * THIS FILE IS PART OF THE OggTheora SOFTWARE CODEC SOURCE CODE.   *
4  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
5  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
6  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
7  *                                                                  *
8  * THE Theora SOURCE CODE IS COPYRIGHT (C) 2002-2005                *
9  * by the Xiph.Org Foundation http://www.xiph.org/                  *
10  *                                                                  *
11  ********************************************************************
12
13   function:
14   last mod: $Id: toplevel.c,v 1.39 2004/03/18 02:00:30 giles Exp $
15
16  ********************************************************************/
17
18 #ifdef HAVE_CONFIG_H
19 # include "config.h"
20 #endif
21
22 #include <stdlib.h>
23 #include <string.h>
24 #include <theora/theora.h>
25 #include "toplevel.h"
26
27 static int _ilog(unsigned int v){
28   int ret=0;
29   while(v){
30     ret++;
31     v>>=1;
32   }
33   return(ret);
34 }
35
36 const char *theora_version_string(void){
37   return VENDOR_STRING;
38 }
39
40 ogg_uint32_t theora_version_number(void){
41   return (VERSION_MAJOR<<16) + (VERSION_MINOR<<8) + (VERSION_SUB);
42 }
43
44
45 static void _tp_readbuffer(oggpack_buffer *opb, char *buf, const long len)
46 {
47   long i;
48   long ret;
49
50   for (i = 0; i < len; i++) {
51     theora_read(opb, 8, &ret);
52     *buf++=(char)ret;
53   }
54 }
55
56 static void _tp_readlsbint(oggpack_buffer *opb, long *value)
57 {
58   int i;
59   long ret[4];
60
61   for (i = 0; i < 4; i++) {
62     theora_read(opb,8,&ret[i]);
63   }
64   *value = ret[0]|ret[1]<<8|ret[2]<<16|ret[3]<<24;
65 }
66
67 void theora_info_init(theora_info *c) {
68   memset(c,0,sizeof(*c));
69   c->codec_setup=_ogg_calloc(1,sizeof(codec_setup_info));
70 }
71
72 void theora_info_clear(theora_info *c) {
73   codec_setup_info *ci=c->codec_setup;
74   int i;
75   if(ci){
76     if(ci->qmats) _ogg_free(ci->qmats);
77     for(i=0;i<6;i++)
78       if(ci->range_table[i]) _ogg_free(ci->range_table[i]);
79     ClearHuffmanTrees(ci->HuffRoot);
80     _ogg_free(ci);
81   }
82   memset(c,0,sizeof(*c));
83 }
84
85 void theora_clear(theora_state *t){
86   if(t){
87     CP_INSTANCE *cpi=(CP_INSTANCE *)(t->internal_encode);
88     PB_INSTANCE *pbi=(PB_INSTANCE *)(t->internal_decode);
89
90     if (cpi) theora_encoder_clear (cpi);
91
92     if(pbi){
93
94       theora_info_clear(&pbi->info);
95       ClearHuffmanSet(pbi);
96       ClearFragmentInfo(pbi);
97       ClearFrameInfo(pbi);
98       ClearPBInstance(pbi);
99
100       _ogg_free(t->internal_decode);
101     }
102
103     t->internal_encode=NULL;
104     t->internal_decode=NULL;
105   }
106 }
107
108 /********************** The toplevel: decode ***********************/
109
110 static int _theora_unpack_info(theora_info *ci, oggpack_buffer *opb){
111   long ret;
112
113   theora_read(opb,8,&ret);
114   ci->version_major=(unsigned char)ret;
115   theora_read(opb,8,&ret);
116   ci->version_minor=(unsigned char)ret;
117   theora_read(opb,8,&ret);
118   ci->version_subminor=(unsigned char)ret;
119
120   if(ci->version_major!=VERSION_MAJOR)return(OC_VERSION);
121   if(ci->version_minor>VERSION_MINOR)return(OC_VERSION);
122
123   theora_read(opb,16,&ret);
124   ci->width=ret<<4;
125   theora_read(opb,16,&ret);
126   ci->height=ret<<4;
127   theora_read(opb,24,&ret);
128   ci->frame_width=ret;
129   theora_read(opb,24,&ret);
130   ci->frame_height=ret;
131   theora_read(opb,8,&ret);
132   ci->offset_x=ret;
133   theora_read(opb,8,&ret);
134   ci->offset_y=ret;
135
136   theora_read(opb,32,&ret);
137   ci->fps_numerator=ret;
138   theora_read(opb,32,&ret);
139   ci->fps_denominator=ret;
140   theora_read(opb,24,&ret);
141   ci->aspect_numerator=ret;
142   theora_read(opb,24,&ret);
143   ci->aspect_denominator=ret;
144
145   theora_read(opb,8,&ret);
146   ci->colorspace=ret;
147   theora_read(opb,24,&ret);
148   ci->target_bitrate=ret;
149   theora_read(opb,6,&ret);
150   ci->quality=ret;
151
152   theora_read(opb,5,&ret);
153   ci->keyframe_frequency_force=1<<ret;
154
155   theora_read(opb,2,&ret);
156   ci->pixelformat=ret;
157
158   /* spare configuration bits */
159   if ( theora_read(opb,3,&ret) == -1 )
160     return (OC_BADHEADER);
161
162   return(0);
163 }
164
165 static int _theora_unpack_comment(theora_comment *tc, oggpack_buffer *opb){
166   int i;
167   int len;
168
169    _tp_readlsbint(opb,(long *) &len);
170   if(len<0)return(OC_BADHEADER);
171   tc->vendor=_ogg_calloc(1,len+1);
172   _tp_readbuffer(opb,tc->vendor, len);
173   tc->vendor[len]='\0';
174
175   _tp_readlsbint(opb,(long *) &tc->comments);
176   if(tc->comments<0)goto parse_err;
177   tc->user_comments=_ogg_calloc(tc->comments,sizeof(*tc->user_comments));
178   tc->comment_lengths=_ogg_calloc(tc->comments,sizeof(*tc->comment_lengths));
179   for(i=0;i<tc->comments;i++){
180     _tp_readlsbint(opb,(long *)&len);
181     if(len<0)goto parse_err;
182     tc->user_comments[i]=_ogg_calloc(1,len+1);
183     _tp_readbuffer(opb,tc->user_comments[i],len);
184     tc->user_comments[i][len]='\0';
185     tc->comment_lengths[i]=len;
186   }
187   return(0);
188
189 parse_err:
190   theora_comment_clear(tc);
191   return(OC_BADHEADER);
192 }
193
194 static int _theora_unpack_tables(theora_info *c, oggpack_buffer *opb){
195   codec_setup_info *ci;
196   int ret;
197
198   ci=(codec_setup_info *)c->codec_setup;
199
200   ret=ReadFilterTables(ci, opb);
201   if(ret)return ret;
202   ret=ReadQTables(ci, opb);
203   if(ret)return ret;
204   ret=ReadHuffmanTrees(ci, opb);
205   if(ret)return ret;
206
207   return ret;
208 }
209
210 int theora_decode_header(theora_info *ci, theora_comment *cc, ogg_packet *op){
211   long ret;
212   oggpack_buffer *opb;
213   
214   if(!op)return OC_BADHEADER;
215   
216 #ifndef LIBOGG2
217   opb = _ogg_malloc(sizeof(oggpack_buffer));
218   oggpackB_readinit(opb,op->packet,op->bytes);
219 #else
220   opb = _ogg_malloc(oggpack_buffersize());
221   oggpackB_readinit(opb,op->packet);
222 #endif
223   {
224     char id[6];
225     int typeflag;
226     
227     theora_read(opb,8,&ret);
228     typeflag = ret;
229     if(!(typeflag&0x80)) {
230       free(opb);
231       return(OC_NOTFORMAT);
232     }
233
234     _tp_readbuffer(opb,id,6);
235     if(memcmp(id,"theora",6)) {
236       free(opb);
237       return(OC_NOTFORMAT);
238     }
239
240     switch(typeflag){
241     case 0x80:
242       if(!op->b_o_s){
243         /* Not the initial packet */
244         free(opb);
245         return(OC_BADHEADER);
246       }
247       if(ci->version_major!=0){
248         /* previously initialized info header */
249         free(opb);
250         return OC_BADHEADER;
251       }
252
253       ret = _theora_unpack_info(ci,opb);
254       free(opb);
255       return(ret);
256
257     case 0x81:
258       if(ci->version_major==0){
259         /* um... we didn't get the initial header */
260         free(opb);
261         return(OC_BADHEADER);
262       }
263
264       ret = _theora_unpack_comment(cc,opb);
265       free(opb);
266       return(ret);
267
268     case 0x82:
269       if(ci->version_major==0 || cc->vendor==NULL){
270         /* um... we didn't get the initial header or comments yet */
271         free(opb);
272         return(OC_BADHEADER);
273       }
274
275       ret = _theora_unpack_tables(ci,opb);
276       free(opb);
277       return(ret);
278     
279     default:
280       free(opb);
281       if(ci->version_major==0 || cc->vendor==NULL || 
282          ((codec_setup_info *)ci->codec_setup)->HuffRoot[0]==NULL){
283         /* we haven't gotten the three required headers */
284         return(OC_BADHEADER);
285       }
286       /* ignore any trailing header packets for forward compatibility */
287       return(OC_NEWPACKET);
288     }
289   }
290   /* I don't think it's possible to get this far, but better safe.. */
291   free(opb);
292   return(OC_BADHEADER);
293 }
294
295 int theora_decode_init(theora_state *th, theora_info *c){
296   PB_INSTANCE *pbi;
297   codec_setup_info *ci;
298
299   ci=(codec_setup_info *)c->codec_setup;
300   memset(th, 0, sizeof(*th));
301   th->internal_decode=pbi=_ogg_calloc(1,sizeof(*pbi));
302   th->internal_encode=NULL;
303
304   InitPBInstance(pbi);
305   memcpy(&pbi->info,c,sizeof(*c));
306   pbi->info.codec_setup=NULL;
307   th->i=&pbi->info;
308   th->granulepos=-1;
309
310   InitFrameDetails(pbi);
311
312   pbi->keyframe_granule_shift=_ilog(c->keyframe_frequency_force-1);
313
314   pbi->LastFrameQualityValue = 0;
315   pbi->DecoderErrorCode = 0;
316
317   /* Clear down the YUVtoRGB conversion skipped list. */
318   memset(pbi->skipped_display_fragments, 0, pbi->UnitFragments );
319
320   /* Initialise version specific quantiser and in-loop filter values */
321   CopyQTables(pbi, ci);
322   CopyFilterTables(pbi, ci);
323
324   /* Huffman setup */
325   InitHuffmanTrees(pbi, ci);
326
327   return(0);
328
329 }
330
331 int theora_decode_packetin(theora_state *th,ogg_packet *op){
332   long ret;
333   PB_INSTANCE *pbi=(PB_INSTANCE *)(th->internal_decode);
334
335   pbi->DecoderErrorCode = 0;
336
337 #ifndef LIBOGG2
338   oggpackB_readinit(pbi->opb,op->packet,op->bytes);
339 #else
340   oggpackB_readinit(pbi->opb,op->packet);
341 #endif
342
343   /* verify that this is a video frame */
344   theora_read(pbi->opb,1,&ret);
345
346   if (ret==0) {
347     ret=LoadAndDecode(pbi);
348
349     if(ret)return ret;
350
351     if(pbi->PostProcessingLevel)
352       PostProcess(pbi);
353
354     if(op->granulepos>-1)
355       th->granulepos=op->granulepos;
356     else{
357       if(th->granulepos==-1){
358         th->granulepos=0;
359       }else{
360         if(pbi->FrameType==BASE_FRAME){
361           long frames= th->granulepos & ((1<<pbi->keyframe_granule_shift)-1);
362           th->granulepos>>=pbi->keyframe_granule_shift;
363           th->granulepos+=frames+1;
364           th->granulepos<<=pbi->keyframe_granule_shift;
365         }else
366           th->granulepos++;
367       }
368     }
369
370     return(0);
371   }
372
373   return OC_BADPACKET;
374 }
375
376 int theora_decode_YUVout(theora_state *th,yuv_buffer *yuv){
377   PB_INSTANCE *pbi=(PB_INSTANCE *)(th->internal_decode);
378
379   yuv->y_width = pbi->info.width;
380   yuv->y_height = pbi->info.height;
381   yuv->y_stride = pbi->YStride;
382
383   yuv->uv_width = pbi->info.width / 2;
384   yuv->uv_height = pbi->info.height / 2;
385   yuv->uv_stride = pbi->UVStride;
386
387   if(pbi->PostProcessingLevel){
388     yuv->y = &pbi->PostProcessBuffer[pbi->ReconYDataOffset];
389     yuv->u = &pbi->PostProcessBuffer[pbi->ReconUDataOffset];
390     yuv->v = &pbi->PostProcessBuffer[pbi->ReconVDataOffset];
391   }else{
392     yuv->y = &pbi->LastFrameRecon[pbi->ReconYDataOffset];
393     yuv->u = &pbi->LastFrameRecon[pbi->ReconUDataOffset];
394     yuv->v = &pbi->LastFrameRecon[pbi->ReconVDataOffset];
395   }
396   
397   /* we must flip the internal representation,
398      so make the stride negative and start at the end */
399   yuv->y += yuv->y_stride * (yuv->y_height - 1);
400   yuv->u += yuv->uv_stride * (yuv->uv_height - 1);
401   yuv->v += yuv->uv_stride * (yuv->uv_height - 1);
402   yuv->y_stride = - yuv->y_stride;
403   yuv->uv_stride = - yuv->uv_stride;
404
405   return 0;
406 }
407
408 /* returns, in seconds, absolute time of current packet in given
409    logical stream */
410 double theora_granule_time(theora_state *th,ogg_int64_t granulepos){
411 #if THEORA_SUPPORT_FLOAT
412   CP_INSTANCE *cpi=(CP_INSTANCE *)(th->internal_encode);
413   PB_INSTANCE *pbi=(PB_INSTANCE *)(th->internal_decode);
414
415   if(cpi)pbi=&cpi->pb;
416
417   if(granulepos>=0){
418     ogg_int64_t iframe=granulepos>>pbi->keyframe_granule_shift;
419     ogg_int64_t pframe=granulepos-(iframe<<pbi->keyframe_granule_shift);
420
421     return (iframe+pframe)*
422       ((double)pbi->info.fps_denominator/pbi->info.fps_numerator);
423
424   }
425 #endif
426
427   return(-1);
428 }
429
430 /* check for header flag */
431 int theora_packet_isheader(ogg_packet *op)
432 {
433   return (op->packet[0] & 0x80) ? 1 : 0;
434 }
435
436 /* check for keyframe */
437 int theora_packet_iskeyframe(ogg_packet *op)
438 {
439   if (op->packet[0] & 0x80) return -1; /* not a data packet */
440   return (op->packet[0] & 0x40) ? 0 : 1; /* inter or intra */
441 }
442
443 /* returns frame number of current packet in given logical stream */
444 ogg_int64_t theora_granule_frame(theora_state *th,ogg_int64_t granulepos){
445   CP_INSTANCE *cpi=(CP_INSTANCE *)(th->internal_encode);
446   PB_INSTANCE *pbi=(PB_INSTANCE *)(th->internal_decode);
447
448   if(cpi)pbi=&cpi->pb;
449
450   if(granulepos>=0){
451     ogg_int64_t iframe=granulepos>>pbi->keyframe_granule_shift;
452     ogg_int64_t pframe=granulepos-(iframe<<pbi->keyframe_granule_shift);
453
454     return (iframe+pframe);
455   }
456
457   return(-1);
458 }