root/rat/trunk/codec_types.c @ 2958

Revision 2958, 3.8 KB (checked in by ucaccsp, 15 years ago)

And change them all to be uint32, etc

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*
2 * FILE:      codec_types.c
3 * AUTHOR(S): Orion Hodson
4 *     
5 * $Revision$
6 * $Date$
7 *
8 * Copyright (c) 1999 University College London
9 * All rights reserved.
10 *
11 */
12#include "config_unix.h"
13#include "config_win32.h"
14
15#include "codec_types.h"
16
17#include "util.h"
18#include "debug.h"
19
20int 
21media_data_create(media_data **ppmd, int nrep)
22{
23        media_data *pmd;
24        int i;
25
26        *ppmd = NULL;
27        pmd   = (media_data*)block_alloc(sizeof(media_data));
28       
29        if (pmd) {
30                memset(pmd, 0, sizeof(media_data));
31                for(i = 0; i < nrep; i++) {
32                        pmd->rep[i] = block_alloc(sizeof(coded_unit));
33                        if (pmd->rep[i] == NULL) {
34                                pmd->nrep = i;
35                                media_data_destroy(&pmd, sizeof(media_data));
36                                return FALSE;
37                        }
38                        memset(pmd->rep[i], 0, sizeof(coded_unit));
39                }
40                pmd->nrep    = nrep;
41                *ppmd = pmd;
42                return TRUE;
43        }
44        return FALSE;
45}
46
47void 
48media_data_destroy(media_data **ppmd, uint32_t md_size)
49{
50        media_data *pmd;
51        coded_unit *pcu;
52        int         i;
53       
54        pmd = *ppmd;
55
56        assert(pmd != NULL);
57        assert(md_size == sizeof(media_data));
58
59        for(i = 0; i < pmd->nrep; i++) {
60                pcu = pmd->rep[i];
61                if (pcu->state) {
62                        block_free(pcu->state, pcu->state_len);
63                        pcu->state     = 0;
64                        pcu->state_len = 0;
65                }
66                assert(pcu->state_len == 0);
67                if (pcu->data) {
68                        block_free(pcu->data, pcu->data_len);
69                        pcu->data     = 0;
70                        pcu->data_len = 0;
71                }
72                assert(pcu->data_len == 0);
73                block_free(pcu, sizeof(coded_unit));
74        }
75#ifdef DEBUG_MEM
76        for(i = pmd->nrep; i < MAX_MEDIA_UNITS; i++) {
77                if (pmd->rep[i] != NULL) {
78                        assert(pmd->rep[i]->state == NULL);
79                        assert(pmd->rep[i]->data  == NULL);
80                }
81        }
82#endif /* DEBUG_MEM */
83
84        block_free(pmd, sizeof(media_data));
85        *ppmd = NULL;
86}
87
88int
89coded_unit_dup(coded_unit *dst, coded_unit *src)
90{
91        assert(dst != NULL);
92        assert(src != NULL);
93        assert(src->data_len != 0);
94
95        dst->data     = (u_char*)block_alloc(src->data_len);
96        dst->data_len = src->data_len;
97
98        memcpy(dst->data, src->data, src->data_len);
99
100        if (src->state_len != 0) {
101                dst->state     = (u_char*)block_alloc(src->state_len);
102                dst->state_len = src->state_len;
103                memcpy(dst->state, src->state, src->state_len);
104        } else {
105                dst->state     = NULL;
106                dst->state_len = 0;
107        }
108
109        dst->id = src->id;
110
111        return TRUE;
112}
113
114
115void
116coded_unit_layer_split(coded_unit *in, coded_unit *out, uint8_t layer, uint8_t *layer_markers)
117{
118        uint16_t tmp_datalen;
119        uint8_t i;
120
121        tmp_datalen = (uint16_t)(layer_markers[layer] - layer_markers[layer-1]);
122
123        out->data = (u_char*)block_alloc(tmp_datalen);
124        out->data_len = tmp_datalen;
125
126        for(i=layer_markers[layer-1];i<layer_markers[layer];i++) {
127                out->data[i-layer_markers[layer-1]] = in->data[i];
128        }
129       
130        if (in->state_len != 0) {
131                out->state     = (u_char*)block_alloc(in->state_len);
132                out->state_len = in->state_len;
133                memcpy(out->state, in->state, in->state_len);
134        } else {
135                in->state     = NULL;
136                in->state_len = 0;
137        }
138
139        out->id = in->id;
140}
Note: See TracBrowser for help on using the browser.