root/rat/trunk/codec_types.c @ 2966

Revision 2966, 4.5 KB (checked in by ucacoxh, 14 years ago)

- Added media_data_dup for duplicating media_data units.

  • 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
88/* media_data_dup duplicate a media data unit.  Copies data from src to a    */
89/* new unit dst.  Returns TRUE on success.                                   */
90int 
91media_data_dup(media_data **dst, media_data *src)
92{
93        media_data *m;
94        uint8_t    i;
95
96        if (media_data_create(&m, src->nrep) == FALSE) {
97                *dst = NULL;
98                return FALSE;
99        }
100
101        for(i = 0; i < src->nrep; i++) {
102                if (coded_unit_dup(m->rep[i], src->rep[i]) == FALSE) {
103                        goto media_dup_failure;
104                }
105        }
106        *dst = m;
107        return TRUE;
108
109media_dup_failure:
110        media_data_destroy(&m, sizeof(media_data));
111        return FALSE;
112}
113
114int
115coded_unit_dup(coded_unit *dst, coded_unit *src)
116{
117        assert(dst != NULL);
118        assert(src != NULL);
119        assert(src->data_len != 0);
120
121        dst->data     = (u_char*)block_alloc(src->data_len);
122        dst->data_len = src->data_len;
123
124        memcpy(dst->data, src->data, src->data_len);
125
126        if (src->state_len != 0) {
127                dst->state     = (u_char*)block_alloc(src->state_len);
128                dst->state_len = src->state_len;
129                memcpy(dst->state, src->state, src->state_len);
130        } else {
131                dst->state     = NULL;
132                dst->state_len = 0;
133        }
134
135        dst->id = src->id;
136
137        return TRUE;
138}
139
140
141void
142coded_unit_layer_split(coded_unit *in, coded_unit *out, uint8_t layer, uint8_t *layer_markers)
143{
144        uint16_t tmp_datalen;
145        uint8_t i;
146
147        tmp_datalen = (uint16_t)(layer_markers[layer] - layer_markers[layer-1]);
148
149        out->data = (u_char*)block_alloc(tmp_datalen);
150        out->data_len = tmp_datalen;
151
152        for(i=layer_markers[layer-1];i<layer_markers[layer];i++) {
153                out->data[i-layer_markers[layer-1]] = in->data[i];
154        }
155       
156        if (in->state_len != 0) {
157                out->state     = (u_char*)block_alloc(in->state_len);
158                out->state_len = in->state_len;
159                memcpy(out->state, in->state, in->state_len);
160        } else {
161                in->state     = NULL;
162                in->state_len = 0;
163        }
164
165        out->id = in->id;
166}
Note: See TracBrowser for help on using the browser.