PageRenderTime 135ms CodeModel.GetById 114ms app.highlight 16ms RepoModel.GetById 1ms app.codeStats 0ms

/H264Dec/source/h264bsd_seq_param_set.c

http://github.com/mbebenita/Broadway
C | 577 lines | 356 code | 80 blank | 141 comment | 113 complexity | 312229a06c188cee002d58b1d0313b38 MD5 | raw file
  1/*
  2 * Copyright (C) 2009 The Android Open Source Project
  3 *
  4 * Licensed under the Apache License, Version 2.0 (the "License");
  5 * you may not use this file except in compliance with the License.
  6 * You may obtain a copy of the License at
  7 *
  8 *      http://www.apache.org/licenses/LICENSE-2.0
  9 *
 10 * Unless required by applicable law or agreed to in writing, software
 11 * distributed under the License is distributed on an "AS IS" BASIS,
 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 * See the License for the specific language governing permissions and
 14 * limitations under the License.
 15 */
 16
 17/*------------------------------------------------------------------------------
 18
 19    Table of contents
 20
 21     1. Include headers
 22     2. External compiler flags
 23     3. Module defines
 24     4. Local function prototypes
 25     5. Functions
 26          h264bsdDecodeSeqParamSet
 27          GetDpbSize
 28          h264bsdCompareSeqParamSets
 29
 30------------------------------------------------------------------------------*/
 31
 32/*------------------------------------------------------------------------------
 33    1. Include headers
 34------------------------------------------------------------------------------*/
 35
 36#include "h264bsd_seq_param_set.h"
 37#include "h264bsd_util.h"
 38#include "h264bsd_vlc.h"
 39#include "h264bsd_vui.h"
 40#include "h264bsd_cfg.h"
 41
 42/*------------------------------------------------------------------------------
 43    2. External compiler flags
 44--------------------------------------------------------------------------------
 45
 46--------------------------------------------------------------------------------
 47    3. Module defines
 48------------------------------------------------------------------------------*/
 49
 50/* enumeration to indicate invalid return value from the GetDpbSize function */
 51enum {INVALID_DPB_SIZE = 0x7FFFFFFF};
 52
 53/*------------------------------------------------------------------------------
 54    4. Local function prototypes
 55------------------------------------------------------------------------------*/
 56
 57static u32 GetDpbSize(u32 picSizeInMbs, u32 levelIdc);
 58
 59/*------------------------------------------------------------------------------
 60
 61    Function name: h264bsdDecodeSeqParamSet
 62
 63        Functional description:
 64            Decode sequence parameter set information from the stream.
 65
 66            Function allocates memory for offsetForRefFrame array if
 67            picture order count type is 1 and numRefFramesInPicOrderCntCycle
 68            is greater than zero.
 69
 70        Inputs:
 71            pStrmData       pointer to stream data structure
 72
 73        Outputs:
 74            pSeqParamSet    decoded information is stored here
 75
 76        Returns:
 77            HANTRO_OK       success
 78            HANTRO_NOK      failure, invalid information or end of stream
 79            MEMORY_ALLOCATION_ERROR for memory allocation failure
 80
 81------------------------------------------------------------------------------*/
 82
 83u32 h264bsdDecodeSeqParamSet(strmData_t *pStrmData, seqParamSet_t *pSeqParamSet)
 84{
 85
 86/* Variables */
 87
 88    u32 tmp, i, value;
 89
 90/* Code */
 91
 92    ASSERT(pStrmData);
 93    ASSERT(pSeqParamSet);
 94
 95    H264SwDecMemset(pSeqParamSet, 0, sizeof(seqParamSet_t));
 96
 97    /* profile_idc */
 98    tmp = h264bsdGetBits(pStrmData, 8);
 99    if (tmp == END_OF_STREAM)
100        return(HANTRO_NOK);
101    if (tmp != 66)
102    {
103        DEBUG(("NOT BASELINE PROFILE %d\n", tmp));
104    }
105    pSeqParamSet->profileIdc = tmp;
106
107    /* constrained_set0_flag */
108    tmp = h264bsdGetBits(pStrmData, 1);
109    /* constrained_set1_flag */
110    tmp = h264bsdGetBits(pStrmData, 1);
111    /* constrained_set2_flag */
112    tmp = h264bsdGetBits(pStrmData, 1);
113
114    if (tmp == END_OF_STREAM)
115        return(HANTRO_NOK);
116
117    /* reserved_zero_5bits, values of these bits shall be ignored */
118    tmp = h264bsdGetBits(pStrmData, 5);
119    if (tmp == END_OF_STREAM)
120        return(HANTRO_NOK);
121
122    tmp = h264bsdGetBits(pStrmData, 8);
123    if (tmp == END_OF_STREAM)
124        return(HANTRO_NOK);
125    pSeqParamSet->levelIdc = tmp;
126
127    tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
128        &pSeqParamSet->seqParameterSetId);
129    if (tmp != HANTRO_OK)
130        return(tmp);
131    if (pSeqParamSet->seqParameterSetId >= MAX_NUM_SEQ_PARAM_SETS)
132    {
133        EPRINT("seq_param_set_id");
134        return(HANTRO_NOK);
135    }
136
137    /* log2_max_frame_num_minus4 */
138    tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
139    if (tmp != HANTRO_OK)
140        return(tmp);
141    if (value > 12)
142    {
143        EPRINT("log2_max_frame_num_minus4");
144        return(HANTRO_NOK);
145    }
146    /* maxFrameNum = 2^(log2_max_frame_num_minus4 + 4) */
147    pSeqParamSet->maxFrameNum = 1 << (value+4);
148
149    /* valid POC types are 0, 1 and 2 */
150    tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
151    if (tmp != HANTRO_OK)
152        return(tmp);
153    if (value > 2)
154    {
155        EPRINT("pic_order_cnt_type");
156        return(HANTRO_NOK);
157    }
158    pSeqParamSet->picOrderCntType = value;
159
160    if (pSeqParamSet->picOrderCntType == 0)
161    {
162        /* log2_max_pic_order_cnt_lsb_minus4 */
163        tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
164        if (tmp != HANTRO_OK)
165            return(tmp);
166        if (value > 12)
167        {
168            EPRINT("log2_max_pic_order_cnt_lsb_minus4");
169            return(HANTRO_NOK);
170        }
171        /* maxPicOrderCntLsb = 2^(log2_max_pic_order_cnt_lsb_minus4 + 4) */
172        pSeqParamSet->maxPicOrderCntLsb = 1 << (value+4);
173    }
174    else if (pSeqParamSet->picOrderCntType == 1)
175    {
176        tmp = h264bsdGetBits(pStrmData, 1);
177        if (tmp == END_OF_STREAM)
178            return(HANTRO_NOK);
179        pSeqParamSet->deltaPicOrderAlwaysZeroFlag = (tmp == 1) ?
180                                        HANTRO_TRUE : HANTRO_FALSE;
181
182        tmp = h264bsdDecodeExpGolombSigned(pStrmData,
183            &pSeqParamSet->offsetForNonRefPic);
184        if (tmp != HANTRO_OK)
185            return(tmp);
186
187        tmp = h264bsdDecodeExpGolombSigned(pStrmData,
188            &pSeqParamSet->offsetForTopToBottomField);
189        if (tmp != HANTRO_OK)
190            return(tmp);
191
192        tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
193            &pSeqParamSet->numRefFramesInPicOrderCntCycle);
194        if (tmp != HANTRO_OK)
195            return(tmp);
196        if (pSeqParamSet->numRefFramesInPicOrderCntCycle > 255)
197        {
198            EPRINT("num_ref_frames_in_pic_order_cnt_cycle");
199            return(HANTRO_NOK);
200        }
201
202        if (pSeqParamSet->numRefFramesInPicOrderCntCycle)
203        {
204            /* NOTE: This has to be freed somewhere! */
205            ALLOCATE(pSeqParamSet->offsetForRefFrame,
206                     pSeqParamSet->numRefFramesInPicOrderCntCycle, i32);
207            if (pSeqParamSet->offsetForRefFrame == NULL)
208                return(MEMORY_ALLOCATION_ERROR);
209
210            for (i = 0; i < pSeqParamSet->numRefFramesInPicOrderCntCycle; i++)
211            {
212                tmp =  h264bsdDecodeExpGolombSigned(pStrmData,
213                    pSeqParamSet->offsetForRefFrame + i);
214                if (tmp != HANTRO_OK)
215                    return(tmp);
216            }
217        }
218        else
219        {
220            pSeqParamSet->offsetForRefFrame = NULL;
221        }
222    }
223
224    tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
225        &pSeqParamSet->numRefFrames);
226    if (tmp != HANTRO_OK)
227        return(tmp);
228    if (pSeqParamSet->numRefFrames > MAX_NUM_REF_PICS)
229    {
230        EPRINT("num_ref_frames");
231        return(HANTRO_NOK);
232    }
233
234    tmp = h264bsdGetBits(pStrmData, 1);
235    if (tmp == END_OF_STREAM)
236        return(HANTRO_NOK);
237    pSeqParamSet->gapsInFrameNumValueAllowedFlag = (tmp == 1) ?
238                                        HANTRO_TRUE : HANTRO_FALSE;
239
240    tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
241    if (tmp != HANTRO_OK)
242        return(tmp);
243    pSeqParamSet->picWidthInMbs = value + 1;
244
245    tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &value);
246    if (tmp != HANTRO_OK)
247        return(tmp);
248    pSeqParamSet->picHeightInMbs = value + 1;
249
250    /* frame_mbs_only_flag, shall be 1 for baseline profile */
251    tmp = h264bsdGetBits(pStrmData, 1);
252    if (tmp == END_OF_STREAM)
253        return(HANTRO_NOK);
254    if (!tmp)
255    {
256        EPRINT("frame_mbs_only_flag");
257        return(HANTRO_NOK);
258    }
259
260    /* direct_8x8_inference_flag */
261    tmp = h264bsdGetBits(pStrmData, 1);
262    if (tmp == END_OF_STREAM)
263        return(HANTRO_NOK);
264
265    tmp = h264bsdGetBits(pStrmData, 1);
266    if (tmp == END_OF_STREAM)
267        return(HANTRO_NOK);
268    pSeqParamSet->frameCroppingFlag = (tmp == 1) ? HANTRO_TRUE : HANTRO_FALSE;
269
270    if (pSeqParamSet->frameCroppingFlag)
271    {
272        tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
273            &pSeqParamSet->frameCropLeftOffset);
274        if (tmp != HANTRO_OK)
275            return(tmp);
276        tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
277            &pSeqParamSet->frameCropRightOffset);
278        if (tmp != HANTRO_OK)
279            return(tmp);
280        tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
281            &pSeqParamSet->frameCropTopOffset);
282        if (tmp != HANTRO_OK)
283            return(tmp);
284        tmp = h264bsdDecodeExpGolombUnsigned(pStrmData,
285            &pSeqParamSet->frameCropBottomOffset);
286        if (tmp != HANTRO_OK)
287            return(tmp);
288
289        /* check that frame cropping params are valid, parameters shall
290         * specify non-negative area within the original picture */
291        if ( ( (i32)pSeqParamSet->frameCropLeftOffset >
292               ( 8 * (i32)pSeqParamSet->picWidthInMbs -
293                 ((i32)pSeqParamSet->frameCropRightOffset + 1) ) ) ||
294             ( (i32)pSeqParamSet->frameCropTopOffset >
295               ( 8 * (i32)pSeqParamSet->picHeightInMbs -
296                 ((i32)pSeqParamSet->frameCropBottomOffset + 1) ) ) )
297        {
298            EPRINT("frame_cropping");
299            return(HANTRO_NOK);
300        }
301    }
302
303    /* check that image dimensions and levelIdc match */
304    tmp = pSeqParamSet->picWidthInMbs * pSeqParamSet->picHeightInMbs;
305    value = GetDpbSize(tmp, pSeqParamSet->levelIdc);
306    if (value == INVALID_DPB_SIZE || pSeqParamSet->numRefFrames > value)
307    {
308        DEBUG(("WARNING! Invalid DPB size based on SPS Level!\n"));
309        DEBUG(("WARNING! Using num_ref_frames =%d for DPB size!\n",
310                        pSeqParamSet->numRefFrames));
311        value = pSeqParamSet->numRefFrames;
312    }
313    pSeqParamSet->maxDpbSize = value;
314
315    tmp = h264bsdGetBits(pStrmData, 1);
316    if (tmp == END_OF_STREAM)
317        return(HANTRO_NOK);
318    pSeqParamSet->vuiParametersPresentFlag = (tmp == 1) ?
319                                HANTRO_TRUE : HANTRO_FALSE;
320
321    /* VUI */
322    if (pSeqParamSet->vuiParametersPresentFlag)
323    {
324        ALLOCATE(pSeqParamSet->vuiParameters, 1, vuiParameters_t);
325        if (pSeqParamSet->vuiParameters == NULL)
326            return(MEMORY_ALLOCATION_ERROR);
327        tmp = h264bsdDecodeVuiParameters(pStrmData,
328            pSeqParamSet->vuiParameters);
329        if (tmp != HANTRO_OK)
330            return(tmp);
331        /* check numReorderFrames and maxDecFrameBuffering */
332        if (pSeqParamSet->vuiParameters->bitstreamRestrictionFlag)
333        {
334            if (pSeqParamSet->vuiParameters->numReorderFrames >
335                    pSeqParamSet->vuiParameters->maxDecFrameBuffering ||
336                pSeqParamSet->vuiParameters->maxDecFrameBuffering <
337                    pSeqParamSet->numRefFrames ||
338                pSeqParamSet->vuiParameters->maxDecFrameBuffering >
339                    pSeqParamSet->maxDpbSize)
340            {
341                return(HANTRO_NOK);
342            }
343
344            /* standard says that "the sequence shall not require a DPB with
345             * size of more than max(1, maxDecFrameBuffering) */
346            pSeqParamSet->maxDpbSize =
347                MAX(1, pSeqParamSet->vuiParameters->maxDecFrameBuffering);
348        }
349    }
350
351    tmp = h264bsdRbspTrailingBits(pStrmData);
352
353    /* ignore possible errors in trailing bits of parameters sets */
354    return(HANTRO_OK);
355
356}
357
358/*------------------------------------------------------------------------------
359
360    Function: GetDpbSize
361
362        Functional description:
363            Get size of the DPB in frames. Size is determined based on the
364            picture size and MaxDPB for the specified level. These determine
365            how many pictures may fit into to the buffer. However, the size
366            is also limited to a maximum of 16 frames and therefore function
367            returns the minimum of the determined size and 16.
368
369        Inputs:
370            picSizeInMbs    number of macroblocks in the picture
371            levelIdc        indicates the level
372
373        Outputs:
374            none
375
376        Returns:
377            size of the DPB in frames
378            INVALID_DPB_SIZE when invalid levelIdc specified or picSizeInMbs
379            is higher than supported by the level in question
380
381------------------------------------------------------------------------------*/
382
383u32 GetDpbSize(u32 picSizeInMbs, u32 levelIdc)
384{
385
386/* Variables */
387
388    u32 tmp;
389    u32 maxPicSizeInMbs;
390
391/* Code */
392
393    ASSERT(picSizeInMbs);
394
395    /* use tmp as the size of the DPB in bytes, computes as 1024 * MaxDPB
396     * (from table A-1 in Annex A) */
397    switch (levelIdc)
398    {
399        case 10:
400            tmp = 152064;
401            maxPicSizeInMbs = 99;
402            break;
403
404        case 11:
405            tmp = 345600;
406            maxPicSizeInMbs = 396;
407            break;
408
409        case 12:
410            tmp = 912384;
411            maxPicSizeInMbs = 396;
412            break;
413
414        case 13:
415            tmp = 912384;
416            maxPicSizeInMbs = 396;
417            break;
418
419        case 20:
420            tmp = 912384;
421            maxPicSizeInMbs = 396;
422            break;
423
424        case 21:
425            tmp = 1824768;
426            maxPicSizeInMbs = 792;
427            break;
428
429        case 22:
430            tmp = 3110400;
431            maxPicSizeInMbs = 1620;
432            break;
433
434        case 30:
435            tmp = 3110400;
436            maxPicSizeInMbs = 1620;
437            break;
438
439        case 31:
440            tmp = 6912000;
441            maxPicSizeInMbs = 3600;
442            break;
443
444        case 32:
445            tmp = 7864320;
446            maxPicSizeInMbs = 5120;
447            break;
448
449        case 40:
450            tmp = 12582912;
451            maxPicSizeInMbs = 8192;
452            break;
453
454        case 41:
455            tmp = 12582912;
456            maxPicSizeInMbs = 8192;
457            break;
458
459        case 42:
460            tmp = 34816*384;
461            maxPicSizeInMbs = 8704;
462            break;
463
464        case 50:
465            /* standard says 42301440 here, but corrigendum "corrects" this to
466             * 42393600 */
467            tmp = 42393600;
468            maxPicSizeInMbs = 22080;
469            break;
470
471        case 51:
472            tmp = 70778880;
473            maxPicSizeInMbs = 36864;
474            break;
475
476        default:
477            return(INVALID_DPB_SIZE);
478    }
479
480    /* this is not "correct" return value! However, it results in error in
481     * decoding and this was easiest place to check picture size */
482    if (picSizeInMbs > maxPicSizeInMbs)
483        return(INVALID_DPB_SIZE);
484
485    tmp /= (picSizeInMbs*384);
486
487    return(MIN(tmp, 16));
488
489}
490
491/*------------------------------------------------------------------------------
492
493    Function name: h264bsdCompareSeqParamSets
494
495        Functional description:
496            Compare two sequence parameter sets.
497
498        Inputs:
499            pSps1   pointer to a sequence parameter set
500            pSps2   pointer to another sequence parameter set
501
502        Outputs:
503            0       sequence parameter sets are equal
504            1       otherwise
505
506------------------------------------------------------------------------------*/
507
508u32 h264bsdCompareSeqParamSets(seqParamSet_t *pSps1, seqParamSet_t *pSps2)
509{
510
511/* Variables */
512
513    u32 i;
514
515/* Code */
516
517    ASSERT(pSps1);
518    ASSERT(pSps2);
519
520    /* first compare parameters whose existence does not depend on other
521     * parameters and only compare the rest of the params if these are equal */
522    if (pSps1->profileIdc        == pSps2->profileIdc &&
523        pSps1->levelIdc          == pSps2->levelIdc &&
524        pSps1->maxFrameNum       == pSps2->maxFrameNum &&
525        pSps1->picOrderCntType   == pSps2->picOrderCntType &&
526        pSps1->numRefFrames      == pSps2->numRefFrames &&
527        pSps1->gapsInFrameNumValueAllowedFlag ==
528            pSps2->gapsInFrameNumValueAllowedFlag &&
529        pSps1->picWidthInMbs     == pSps2->picWidthInMbs &&
530        pSps1->picHeightInMbs    == pSps2->picHeightInMbs &&
531        pSps1->frameCroppingFlag == pSps2->frameCroppingFlag &&
532        pSps1->vuiParametersPresentFlag == pSps2->vuiParametersPresentFlag)
533    {
534        if (pSps1->picOrderCntType == 0)
535        {
536            if (pSps1->maxPicOrderCntLsb != pSps2->maxPicOrderCntLsb)
537                return 1;
538        }
539        else if (pSps1->picOrderCntType == 1)
540        {
541            if (pSps1->deltaPicOrderAlwaysZeroFlag !=
542                    pSps2->deltaPicOrderAlwaysZeroFlag ||
543                pSps1->offsetForNonRefPic != pSps2->offsetForNonRefPic ||
544                pSps1->offsetForTopToBottomField !=
545                    pSps2->offsetForTopToBottomField ||
546                pSps1->numRefFramesInPicOrderCntCycle !=
547                    pSps2->numRefFramesInPicOrderCntCycle)
548            {
549                return 1;
550            }
551            else
552            {
553                for (i = 0; i < pSps1->numRefFramesInPicOrderCntCycle; i++)
554                    if (pSps1->offsetForRefFrame[i] !=
555                        pSps2->offsetForRefFrame[i])
556                    {
557                        return 1;
558                    }
559            }
560        }
561        if (pSps1->frameCroppingFlag)
562        {
563            if (pSps1->frameCropLeftOffset   != pSps2->frameCropLeftOffset ||
564                pSps1->frameCropRightOffset  != pSps2->frameCropRightOffset ||
565                pSps1->frameCropTopOffset    != pSps2->frameCropTopOffset ||
566                pSps1->frameCropBottomOffset != pSps2->frameCropBottomOffset)
567            {
568                return 1;
569            }
570        }
571
572        return 0;
573    }
574
575    return 1;
576}
577