[第4波]幽魂系列汉化的有关资料

shane007

最近找到了一些和幽魂系列Phantasmagoria 有关的资料，
# B4 l6 e% ~( m) S* u* g, t也许将来可以用于汉化。

和日文版有关的信息
) o* s- y3 D  {' i/ S6 ^http://anthonylarme.tripod.com/phantas/phintgtp.html
  D9 h( w/ e- k1 r
, ?. F4 c8 d8 p' t+ L1 ^相关工具
http://anthonylarme.tripod.com/phantas/phcheats.html
* V, T& i, P4 _6 L8 r6 o" ?-----------------------------------------------------------------------
2012/1/2  更新
关于幽魂游戏的字幕
Phantasmagoria subtitles function discovered - ScummVM :: Forums
2 x( J5 h$ I6 b# E
VMD文件
Subtitling Sierra VMD Files | Breaking Eggs And Making Omelettes (multimedia.cx)VMD - MultimediaWiki
! _5 k+ `5 `0 O8 Y- d% F. m! F' {
. l& S, v# r& W6 x, G3 M9 Y9 Q' k字幕
Subtitling Sierra RBT Files | Breaking Eggs And Making Omelettes (multimedia.cx)
! S0 W5 `) W( Q; C2 K! {& r6 {6 M3 t
FFmpeg/subtitle-rbt.c at feature/VMD_encoder · multimediamike/FFmpeg · GitHub
2 a6 P$ s: w. R$ T/ R, [

1. /*
   " V1 z, a! n9 L( _' J% h
2. * subtitle-rbt.c
   
3. *  by Mike Melanson (mike -at- multimedia.cx)
   ! E) _% \5 j. y, K! `+ B7 f
4. *
   
5. * build with this command:
   8 i( S4 G9 f3 r% ?! v5 O9 c) a/ m9 g
6. *   gcc -g -Wall subtitle-rbt.c -o subtitle-rbt -lm -lass
   * I+ K" E8 }( R4 J$ D6 {& |
7. */
   % z& x# s3 `/ m- E$ o8 A
8. 
   : B3 x, X: X! `5 k6 Q* A
9. #include <inttypes.h>
   
10. #include <math.h>
    
11. #include <stdio.h>
    ; a9 Z3 P6 e9 [0 |& }+ M
12. #include <stdlib.h>
    # \, V$ k0 n3 Q2 E2 K
13. #include <string.h>
    
14. 
    ! f$ V* u6 b6 T* y$ v% V
15. #include <ass/ass.h>
    
16. 
    
17. #define LE_16(x) ((((uint8_t*)(x))[1] <<  8) | ((uint8_t*)(x))[0])
    - t; H" r9 U( m3 y; ^
18. 
    
19. #define LE_32(x) (((uint32_t)(((uint8_t*)(x))[3]) << 24) |  \
    : \* F: B, U% `! |- r# P
20.                              (((uint8_t*)(x))[2]  << 16) |  \
    
21.                              (((uint8_t*)(x))[1]  <<  8) |  \
    " S* ], [& D0 J# d
22.                               ((uint8_t*)(x))[0])
    
23. 
    
24. /*********************************************************************/
    
25. 
    
26. /* Bit reader stuff */
    9 {* Y) t5 z' Z$ T
27. 
    ' ~$ G* D. j! u0 e6 T5 b# k' \
28. typedef struct
    * X2 G' c  v! h/ n: |6 B
29. {
    
30.     uint8_t *bytestream;
    
31.     int bytestream_size;
    ! U! M  C5 f; l* b( f- T% ~6 \- ]
32.     int index;
    . {; s6 h/ \1 S0 I( |# t% w+ U
33.     uint32_t bits;
    
34.     int bits_in_buffer;
    
35. } get_bits_context;
    
36. 
    , S  z9 H6 c$ n$ H
37. static inline void reload_bits(get_bits_context *gb)
    
38. {
    
39.     while (gb->bits_in_buffer <= 24)
    
40.     {
    
41.         if (gb->index < gb->bytestream_size)
    
42.             gb->bits |= (gb->bytestream[gb->index++] << (24 - gb->bits_in_buffer));
    
43.         gb->bits_in_buffer += 8;
    
44.     }
    
45. }
    $ j- \; z& \( }( A, @
46. 
    
47. static void init_get_bits(get_bits_context *gb, uint8_t *bytestream, int size)
    
48. {
    , e7 ~0 z3 X, }1 e2 k
49.     gb->bytestream = malloc(size);
    
50.     memcpy(gb->bytestream, bytestream, size);
    
51.     gb->bytestream_size = size;
    0 b! w6 @8 k+ O8 V$ d" P9 j
52.     gb->index = 0;
    4 e6 i8 C: `. `2 A% h
53.     gb->bits = 0;
    $ r* g4 ^4 B$ h8 d
54.     gb->bits_in_buffer = 0;
    & N: a! a$ d# T) J7 ~$ |
55. 
    
56.     reload_bits(gb);
    . D2 l; K% E( C! ~" g1 M
57. }
    
58. 
    - T: G& X- w& _! |6 e. [, W* X8 R& r
59. /* read bits without consuming them from the stream */
    
60. static int view_bits(get_bits_context *gb, int count)
    ) v: b. O- i  S: c: P
61. {
    
62.     if (count >= 24)
    
63.         return -1;
    
64.     if (gb->bits_in_buffer < count)
    
65.         reload_bits(gb);
    8 l4 e# Y9 l2 D7 O  |' a) Q, ^0 X
66.     return (gb->bits >> (32 - count));
    
67. }
    
68. 
    
69. /* read and consume bits from the stream */
    
70. static int read_bits(get_bits_context *gb, int count)
    
71. {
    
72.     int value;
    4 v* y/ G! S+ }1 o
73. 
    
74.     if (count >= 24)
    / @/ C& W5 B+ C: O/ o9 @. r
75.         return -1;
    
76. 
    2 j! t6 a" G" s$ c4 _
77.     value = view_bits(gb, count);
    
78.     gb->bits <<= count;
    
79.     gb->bits_in_buffer -= count;
      z+ {0 y. E1 }5 [1 n
80. 
    
81.     return value;
    
82. }
    
83. 
    
84. static void delete_get_bits(get_bits_context *gb)
    
85. {
    ( a7 f. \! ^2 a" H
86.     free(gb->bytestream);
    
87. }
    
88. 
    1 Y3 S, h+ r+ i3 y$ Y* A2 x% c
89. /*********************************************************************/
    
90. 
    4 e' Y+ |" `! m: o) G
91. /* Bit writer stuff */
    
92. 
    
93. #define MAX_PUT_BITS_BYTES 63000
    % w8 s5 w) f  l
94. typedef struct
    8 s+ {' _' L5 o% z
95. {
    6 H! X2 C' i8 V, U
96.     uint8_t bytes[MAX_PUT_BITS_BYTES];
    
97.     int byte_index;
    
98.     uint32_t bit_buffer;
    
99.     int bits_buffered;
    
100. } put_bits_context;
     
101. 
     
102. static void reset_put_bits(put_bits_context *pb)
     ) P0 b  f  L- q) v/ `
103. {
     
104.     memset(pb->bytes, 0, MAX_PUT_BITS_BYTES);
     
105.     pb->byte_index = 0;
     
106.     pb->bit_buffer = 0;
     5 v- I- j  r0 m* B$ e
107.     pb->bits_buffered = 0;
     
108. }
     
109. 
     
110. static put_bits_context *init_put_bits()
     8 S' J8 S. z! L9 L
111. {
     
112.     put_bits_context *pb;
     . I8 @% u1 I* {8 t( m' O  I1 ~
113. 
     
114.     pb = malloc(sizeof(put_bits_context));
     / i' l6 E9 D! ]7 Z/ k
115.     reset_put_bits(pb);
     ) p. U1 A4 @/ I% _) c: A- o
116. 
     & ]2 c2 q" f% O0 c& V9 h: R; ]' r
117.     return pb;
     
118. }
     ' S4 F8 A8 O* z3 q5 q7 m9 f% F7 N
119. 
     ' O# t$ N- B3 |* J: j9 z! i0 z
120. static void put_bits(put_bits_context *pb, int bits, int count)
     % X  j2 O3 P' D" Z0 q
121. {
     
122.     pb->bit_buffer <<= count;
     
123.     pb->bit_buffer |= (bits & (~(0xFFFFFFFF << count)));
     ) Y( ^3 V- Y5 Y, v
124.     pb->bits_buffered += count;
     
125. 
     
126.     while (pb->bits_buffered >= 8)
     # A, P2 @; y" u
127.     {
     
128.         pb->bytes[pb->byte_index++] = pb->bit_buffer >> (pb->bits_buffered - 8);
     ; j% g4 J. b0 |- `4 \; p
129.         pb->bit_buffer &= (~(0xFFFFFFFF << (pb->bits_buffered - 8)));
     
130.         pb->bits_buffered -= 8;
     ' Q% k: l. X2 C. [! V
131.     }
     , ~! T( ~5 j$ u# ?7 l
132. 
     
133.     if (pb->byte_index >= MAX_PUT_BITS_BYTES)
     ( p6 [: v6 E  E! P( Q/ o  c! V
134.     {
     # g. {! x$ Q0 ]9 j
135.         printf("HELP! Bit overflow\n");
     
136.         exit(1);
     8 F9 t& ~, w1 r4 V* B. `
137.     }
     3 A5 X% i: f6 c
138. }
     # P4 P# h/ I) |4 e
139. 
     
140. static void put_bits_flush(put_bits_context *pb)
     
141. {
     
142.     if (pb->bits_buffered > 0)
     ( C6 D, c: l5 W8 K
143.         pb->bytes[pb->byte_index++] = pb->bit_buffer << (8 - pb->bits_buffered);
     ( v0 R. s9 N$ x; C" }
144. }
     
145. 
     
146. static void delete_put_bits(put_bits_context *pb)
     
147. {
     
148.     free(pb->bytes);
     ' e% K" [, [3 L4 P' a* F1 D
149. }
     
150. 
     
151. /*********************************************************************/
     0 A- D* ~9 R) T5 H( L3 z
152. 
     1 y& m" J! z( C1 O% p% A( Q/ @
153. /* RBT functions */
     
154. 
     
155. #define PALETTE_COUNT 256
     
156. #define RBT_HEADER_SIZE 60
       ^' f0 Z% q' P7 i3 R- N" m  a
157. #define UNKNOWN_TABLE_SIZE (1024+512)
     
158. #define SUBTITLE_THRESHOLD 0x70
     + S3 g0 y6 G% A1 g3 o4 z* `- ~
159. #define MILLISECONDS_PER_FRAME 100
     
160. 
     
161. /* VLC table */
       y6 e$ z) F9 t* N  e! D0 ]% Q
162. #define VLC_SIZE 4
     
163. static struct
     ! M8 ^9 T; F7 I- y- I9 d4 y
164. {
     5 Z( c& `; D% t+ C9 z, ^6 S+ q
165.     int count;
     2 B. f$ A6 {: i
166.     int value;
     
167. } lzs_vlc_table[] =
       \! Y7 p* x( U$ `7 |* @
168. {
     
169.     /* code length = 2 bits; value = 2 */
     
170.     /* 0000 */ { 2, 2 },
     
171.     /* 0001 */ { 2, 2 },
     " ~4 t% m3 S. p, L
172.     /* 0010 */ { 2, 2 },
     
173.     /* 0011 */ { 2, 2 },
     
174. 
     
175.     /* code length = 2 bits; value = 3 */
     
176.     /* 0100 */ { 2, 3 },
     
177.     /* 0101 */ { 2, 3 },
     
178.     /* 0110 */ { 2, 3 },
     3 E# {; i% f+ C
179.     /* 0111 */ { 2, 3 },
     7 i) u$ I& s" }
180. 
     
181.     /* code length = 2 bits; value = 4 */
     3 g2 V) H+ D" g# R
182.     /* 1000 */ { 2, 4 },
     
183.     /* 1001 */ { 2, 4 },
     1 p4 Q2 ^  B& {7 q/ R- M) h# T) y
184.     /* 1010 */ { 2, 4 },
     , }6 s3 }, {. @2 l. k
185.     /* 1011 */ { 2, 4 },
     
186. 
     
187.     /* code length = 4 bits; value = 5 */
     0 z$ M; K$ a4 j  N2 q0 O! k2 O
188.     /* 1100 */ { 4, 5 },
     1 C' p5 D& ]! O
189. 
     
190.     /* code length = 4 bits; value = 6 */
     
191.     /* 1101 */ { 4, 6 },
     1 {/ k6 I' P% |2 F( D1 \; ^. _
192. 
     
193.     /* code length = 4 bits; value = 7 */
       D  j2 d2 u6 t6 I# m/ w% s% `& a
194.     /* 1110 */ { 4, 7 },
     ) h7 }/ f! P( M3 k! p
195. 
     8 C0 T" D( {' m
196.     /* special case */
     9 h3 h+ ?6 E* E
197.     /* 1111 */ { 4, 8 }
     1 L5 b  u7 e  Y
198. };
     * v4 P8 t- R+ ^3 n2 s
199. 
     / U; n) f3 b8 o
200. typedef struct
     
201. {
     ; ^/ V9 ]2 g) x& i7 T- D. O! T
202.     int version;
     2 Y( Z3 J+ C' ^) b! f
203.     int width;
     
204.     int height;
     
205.     int frame_count;
     , s5 H9 P$ u. P3 j7 ?
206.     int audio_chunk_size;
     $ W# }9 t5 D* [& s7 S; {7 Z
207.     uint8_t palette[PALETTE_COUNT * 3];
       D! m: z; C5 p  G) f
208.     off_t video_frame_size_table_offset;
     
209.     uint8_t *video_frame_size_table;
     % v, c; k1 v1 T7 T! j7 h, n- ~1 i0 Q
210.     off_t frame_size_table_offset;
     & `1 q: i  |" h+ Z/ i) l
211.     uint8_t *frame_size_table;
     
212.     uint8_t *frame_load_buffer;
     ) @* M3 Q1 \) y3 `
213.     int dump_frames;
     
214. 
     9 n7 \5 d2 }+ l' R; u% N
215.     /* subtitle library */
     8 {( g* f, p$ o! n
216.     ASS_Library *ass_lib;
     ( i3 g: w* ~8 Z! c0 h# U5 l7 B! Z0 x
217.     ASS_Renderer *ass_renderer;
     
218.     ASS_Track *ass_track;
     % p3 ?2 t3 d8 |, T: B4 e' x/ ]. s
219. } rbt_dec_context;
     ; B. F9 D5 K/ ~" p; t- h, _
220. 
     * W! s$ w. R* a- B" b& w0 z* Q
221. static void dump_pnm_file(char *filename, rbt_dec_context *rbt,
     / C$ X4 f1 G6 U: e& a4 Y, j0 ^5 `; T
222.     uint8_t *image, int width, int height)
       B% Q  g/ k/ V( q' f
223. {
     , {5 ?. y7 f. z/ L1 W: }
224.     FILE *outfile;
     
225.     uint8_t bytes[3];
     
226.     int p;
     
227.     uint8_t pixel;
     
228. 
     
229.     outfile = fopen(filename, "wb");
     
230.     fprintf(outfile, "P6\n%d %d\n255\n", width, height);
     
231.     for (p = 0; p < width * height; p++)
     . w+ {1 h# S: U/ K3 Y2 s0 d* y
232.     {
     ; i; d; {. P; {2 ]  ^: O
233.         pixel = image[p];
     * }5 e5 s/ \& E% ~# W* C; {, G
234.         bytes[0] = rbt->palette[pixel*3+0];
     5 @* s& }3 s9 _% T
235.         bytes[1] = rbt->palette[pixel*3+1];
     ; j+ P5 L( }) }- E( [
236.         bytes[2] = rbt->palette[pixel*3+2];
     5 K0 B2 n8 h0 d- b3 J
237.         fwrite(bytes, 3, 1, outfile);
     
238.     }
     ) X1 x' I: K3 [2 p# o! H7 I: y' N
239.     fclose(outfile);
     
240. }
     0 g7 T% c) k! ?: ^6 r
241. 
     0 r2 c( ]) T+ t# m9 _& M
242. static int load_and_copy_rbt_header(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file)
     7 F/ y1 f! C; n& M4 m
243. {
     
244.     uint8_t header[RBT_HEADER_SIZE];
     1 p6 T0 I+ c; @0 G% E! C
245.     int palette_data_size;
     6 u! G9 j; O: v1 }! [' O9 v
246.     uint8_t *palette_chunk;
     
247.     int unknown_chunk_size;
     3 w8 P6 y2 u5 s7 p+ a; Y
248.     uint8_t *unknown_chunk;
     
249.     uint8_t unknown_table[UNKNOWN_TABLE_SIZE];
     
250.     off_t padding_size;
     " x9 m- W: Q, l1 W! F* r* K0 i
251.     uint8_t *padding;
     % X1 A. L3 B  |; |6 U
252.     int i;
     0 S' c/ N3 a1 S0 i. v
253.     int frame_size;
     ; Z& y+ Y" U% J: G- z7 G
254.     int max_frame_size;
     
255.     int first_palette_index;
     
256.     int palette_count;
     7 S* @: |/ G* [) ]- t, u
257.     int palette_type;
     * k0 v1 G& b4 `* o. Q2 h
258.     int palette_index;
     " K. W9 m3 z+ q
259. 
     ' V6 X1 G' \& |. v, S- r; o* A2 c
260.     fseek(inrbt_file, 0, SEEK_SET);
     7 w$ H/ x0 S* \, F$ C
261.     fseek(outrbt_file, 0, SEEK_SET);
     
262. 
     
263.     /* load the header */
     
264.     if (fread(header, RBT_HEADER_SIZE, 1, inrbt_file) != 1)
     
265.     {
     4 A1 B, w0 v: }! B6 O
266.         printf("problem reading initial RBT header\n");
     
267.         return 0;
     
268.     }
     
269. 
     
270.     /* copy header to the output */
     
271.     if (fwrite(header, RBT_HEADER_SIZE, 1, outrbt_file) != 1)
     * K0 C- d# Y* v. c* ^/ {5 h
272.     {
     
273.         printf("problem writing initial RBT header\n");
     ' C  L( _6 w& {4 V
274.         return 0;
     
275.     }
     6 K* e( B' p& N1 p
276. 
     
277.     rbt->version = LE_16(&header[6]);
     5 S7 s: _# P% [# _! L# d
278.     rbt->audio_chunk_size = LE_16(&header[8]);
     
279.     rbt->frame_count = LE_16(&header[14]);
     
280. 
     & I, e. f( \0 T( i
281.     /* transfer the unknown data, if it's there */
     
282.     unknown_chunk_size = LE_16(&header[18]);
     ! g! ^* n7 K* \, F+ F3 Z/ _
283.     if (unknown_chunk_size > 0)
     8 E* v, ?( n* B
284.     {
     
285.         unknown_chunk = malloc(unknown_chunk_size);
     
286.         if (fread(unknown_chunk, unknown_chunk_size, 1, inrbt_file) != 1)
     ( D" h  _, v7 t
287.         {
     # r5 b5 q! ^% g  _& U
288.             printf("problem reading unknown data\n");
     
289.             return 0;
     
290.         }
     ; v3 `: U  I0 K
291.         if (fwrite(unknown_chunk, unknown_chunk_size, 1, outrbt_file) != 1)
     % t0 L* i' F$ I1 `$ I# I
292.         {
     2 j0 N) U7 r; H$ z. `* g" q. F4 l0 M6 z
293.             printf("problem writing unknown data\n");
     
294.             return 0;
     . G- v" C, v7 P/ m/ j% i
295.         }
     7 Z" J) _0 A7 [6 ]
296.         free(unknown_chunk);
     " X6 m6 O( f$ ^$ r1 `# S* @, Q. u6 Y: J. C
297.     }
     6 A7 v0 a6 |( y; y7 I4 a  a+ H
298. 
     
299.     /* transfer the palette chunk */
     
300.     palette_data_size = LE_16(&header[16]);
     $ y  O- |" |7 Y2 [% F( e! H! A
301.     palette_chunk = malloc(palette_data_size);
     0 q) z4 ?  S9 j: ]; S* ~+ e$ S
302.     if (fread(palette_chunk, palette_data_size, 1, inrbt_file) != 1)
     ) B7 b6 l# Y# V, [% p+ Q) Z  M" _( d
303.     {
     
304.         printf("problem reading palette\n");
     
305.         return 0;
     
306.     }
     + x' B; B. D' Q- Y& }" n
307.     if (fwrite(palette_chunk, palette_data_size, 1, outrbt_file) != 1)
     $ p1 \, F5 O& `! n+ T& G1 Y4 ?
308.     {
     , Y- h% ^1 f& R1 E2 o' I) S
309.         printf("problem writing palette\n");
     
310.         return 0;
     
311.     }
     
312.     /* load the palette into the internal context */
     ! I' n0 ~+ N* E: M- q0 F
313.     memset(rbt->palette, 0, PALETTE_COUNT * 3);
     . j* h" E0 J  l5 d7 L9 d
314.     first_palette_index = palette_chunk[25];
     
315.     palette_count = LE_16(&palette_chunk[29]);
     
316.     palette_type = palette_chunk[32];
     . k2 V+ E0 P7 y
317.     palette_index = (palette_type == 0) ? 38 : 37;
     
318.     for (i = first_palette_index; i < first_palette_index + palette_count; i++)
     
319.     {
     8 Q0 l. {, l) `* S7 ?+ S
320.         rbt->palette[i*3+0] = palette_chunk[palette_index++];
     
321.         rbt->palette[i*3+1] = palette_chunk[palette_index++];
     
322.         rbt->palette[i*3+2] = palette_chunk[palette_index++];
     
323.     }
     * r( n# d2 `: g, |0 Z
324.     free(palette_chunk);
     
325. 
     
326.     /* copy the video frame size table (2 bytes per frame), as a placeholder */
     2 l5 e! X7 _( H. O9 a4 M7 u
327.     rbt->video_frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     
328.     if (fread(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     
329.     {
     
330.         printf("problem reading frame table\n");
     9 G9 }: C  P3 v- D5 E) D
331.         return 0;
     
332.     }
     
333.     rbt->video_frame_size_table_offset = ftell(outrbt_file);
     # `; y8 k" Y/ P1 L9 D. L
334.     if (fwrite(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     
335.     {
     $ b" e' n0 W! q) d# @# ~
336.         printf("problem writing frame table\n");
     
337.         return 0;
     
338.     }
     
339. 
     
340.     /* copy the frame size table (2 bytes per frame), as a placeholder */
     
341.     rbt->frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     
342.     if (fread(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     
343.     {
       T* j$ ~# t" c# b$ D3 F1 g" q
344.         printf("problem reading frame table\n");
     
345.         return 0;
     
346.     }
     
347.     rbt->frame_size_table_offset = ftell(outrbt_file);
     : |  [: l* _( J4 k/ T& i9 S0 q& d5 V
348.     if (fwrite(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     
349.     {
     
350.         printf("problem writing frame table\n");
     / P* R1 J+ x9 d* W
351.         return 0;
     ! ?4 m$ U, L9 O9 d  ?, j1 z
352.     }
     2 `. I/ B" R- r, U. t
353. 
     
354.     /* find the max frame size */
     
355.     max_frame_size = 0;
     
356.     for (i = 0; i < rbt->frame_count; i++)
     0 E  N1 c& t* H( W, A4 y$ c3 g
357.     {
     ' B, B% p8 j$ \0 C- F* M
358.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     
359.         if (frame_size > max_frame_size)
     
360.             max_frame_size = frame_size;
     5 ^- z" ?, j2 E+ \
361.     }
     6 v- J, Z5 Z. [- o
362.     rbt->frame_load_buffer = malloc(max_frame_size);
     8 P+ u; j1 |$ }+ v& Q* T4 [8 q) k
363. 
     & T3 B* M: @0 X- j) E" g3 N& \6 N
364.     /* transfer the unknown table(s) */
     
365.     if (fread(unknown_table, UNKNOWN_TABLE_SIZE, 1, inrbt_file) != 1)
     
366.     {
     . Z( C, W+ l0 c  S' x
367.         printf("problem reading unknown table\n");
     
368.         return 0;
     
369.     }
     
370.     if (fwrite(unknown_table, UNKNOWN_TABLE_SIZE, 1, outrbt_file) != 1)
     + {4 o5 A# R9 a
371.     {
     / h, J# q# E7 L5 F
372.         printf("problem writing unknown table\n");
     / h, {5 K1 T) M5 `: t5 T
373.         return 0;
     ' ]$ s' O; u( E  Q
374.     }
     
375. 
     
376.     /* copy over padding */
     
377.     padding_size = 0x800 - (ftell(inrbt_file) & 0x7FF);
     
378.     if (padding_size)
     6 K; k1 f& q5 `9 Q
379.     {
     , j9 {5 p& i& `0 U# B: K
380.         padding = malloc(padding_size);
     ! o, c2 M* I' F8 H" `# |
381.         if (fread(padding, padding_size, 1, inrbt_file) != 1)
     
382.         {
     
383.             printf("problem reading padding\n");
     
384.             return 0;
     
385.         }
     ! Y$ I1 k1 F. S0 A% L
386.         if (fwrite(padding, padding_size, 1, outrbt_file) != 1)
     
387.         {
     " h+ V4 F4 A: ~, x- p
388.             printf("problem writing padding\n");
     
389.             return 0;
     / K2 h6 c" g# f$ w1 o0 F4 p, x, N
390.         }
       i3 \1 v6 Z! ?  h0 j: U3 `
391.         free(padding);
       }4 C+ X! u% S5 j' o  k; ~
392.     }
     
393. 
     / C# L6 c( a- @1 t1 O
394.     return 1;
     
395. }
     7 _! H( k; Q% }9 n+ m. N9 M9 V
396. 
     4 M7 o. Q! _3 x% L5 G2 B2 R
397. static int get_lzs_back_ref_length(get_bits_context *gb)
     
398. {
     & _7 ]$ l+ h8 i# _/ c
399.     int vlc;
     
400.     int count;
     
401.     int value;
     
402. 
     1 i1 K) M4 z% I, _3 C
403.     vlc = view_bits(gb, VLC_SIZE);
     3 i. M& M5 h; t; F2 g. X
404.     count = lzs_vlc_table[vlc].count;
     $ S. t, ^( {- L5 ^" o1 ~6 j
405.     value = lzs_vlc_table[vlc].value;
     6 v& J% ]7 r* s
406. 
     0 q) W, c2 ~5 e5 F$ D7 s" S
407.     read_bits(gb, count);
     ' l! Q$ |) z* x
408.     if (value == 8)
     - K! M3 p2 O2 |! l2 J
409.     {
     % x! e$ j( L: ]( a$ {: X' X
410.         do
     - A# V( n( M4 R6 Q: a
411.         {
     1 Y( c9 n" x) A) c9 x$ |
412.             vlc = read_bits(gb, VLC_SIZE);
     1 K  S  E% T1 a" x1 W0 [
413.             value += vlc;
     ! h& l. g1 ]5 b' d9 \" ?
414.         }
     ; l- l$ v1 S' A6 Z6 _+ A& a
415.         while (vlc == 0xF);
     9 H2 P& T, g  i% ^
416.     }
     
417. 
     
418.     return value;
     
419. }
     ' V; g9 [& w5 K! a( L* t
420. 
     
421. static void compress_window(put_bits_context *pb, uint8_t *full_window,
     
422.     int full_window_stride,
     9 D* M- ^- l$ n& O6 u& |: Q
423.     int window_top, int window_bottom, int window_left, int window_right)
     
424. {
     
425.     int last_pixel;
     5 y4 T& X+ t1 S# Y6 {
426.     int run_size;
     
427.     int x;
     
428.     int y;
     
429.     int start_index;
     
430.     int end_index;
     8 ^" ^- m- ?' p* a$ a& ]# q0 ^
431.     int encode_last_run;
     
432. 
     
433.     last_pixel = full_window[0];
     
434.     run_size = 1;
     $ X. ]# u& i4 T. r3 K
435.     for (y = window_top; y <= window_bottom; y++)
     
436.     {
     5 |7 V6 e) H* ^) F2 i( N; ^
437.         start_index = y * full_window_stride + window_left;
     
438.         if (y == window_top)
     $ G( ]& l6 T. I( \7 j/ X$ M) U8 o
439.             start_index += 1;
     
440.         end_index = y * full_window_stride + window_right;
     
441.         if (y == window_bottom)
     
442.             encode_last_run = 1;
     
443.         else
     
444.             encode_last_run = 0;
     
445.         for (x = start_index; x < end_index; x++)
       A: \, C4 U: y8 Q9 _9 h& B
446.         {
     4 ^9 v: e5 e4 y8 R! z' A# L2 B1 C
447.             if (!encode_last_run && full_window[x] == last_pixel)
     4 {# L- {2 H. g+ p; y
448.                 run_size++;
     8 g2 c% v! i0 v
449.             else
     & J7 i9 c+ c; i, E! h
450.             {
     
451.                 if (run_size == 1)
     7 R; \( P/ s# V1 J7 O: Z
452.                 {
     
453.                     /* encode a 0 bit followed by raw pixel byte */
     
454.                     put_bits(pb, 0, 1);
     
455.                     put_bits(pb, last_pixel, 8);
     
456.                 }
     
457.                 else if (run_size == 2)
     
458.                 {
     
459.                     /* encode a 0 bit followed by raw pixel byte */
     0 g) n$ d. c, P; O1 |7 s$ i1 e
460.                     put_bits(pb, 0, 1);
     
461.                     put_bits(pb, last_pixel, 8);
     7 W( E# `6 U9 P0 F2 o* p$ g
462.                     put_bits(pb, 0, 1);
     1 |+ b2 M) `4 E) d
463.                     put_bits(pb, last_pixel, 8);
     7 i! r/ n: b  o
464.                 }
     ) V8 }- n( k7 r# h) r" J
465.                 else
     
466.                 {
     + T& M3 U4 a# Y( {5 U$ \
467.                     /* encode a 0 bit followed by raw pixel byte */
     
468.                     put_bits(pb, 0, 1);
     9 t; N9 s2 M; v
469.                     put_bits(pb, last_pixel, 8);
       w  U' k- M* e
470.                     run_size--;
     ( U7 g) `: T7 R
471.                     /* encode a run: a 1 bit, followed by a back reference
       O9 K9 e  ~: s5 E
472.                      * offset (-1), followed by a length */
     
473.                     put_bits(pb, 1, 1);
     , \8 ~( i* l6 [2 B- y0 Y  V
474.                     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     * n7 \* |( ?8 B5 I7 V; K
475.                     put_bits(pb, 1, 7);
     # T5 A+ ^' w! l# n
476.                     if (run_size <= 4)
     5 b0 d* k- m: n0 r& |
477.                     {
     , I8 ^  I4 q9 s* r1 O0 {! a
478.                         /* lengths 2, 3, and 4 are 2 bits */
     2 m) _1 o6 \4 ]
479.                         put_bits(pb, run_size - 2, 2);
     % P( J8 Q* ?& \7 Y' n
480.                     }
     / Y1 S% C. \/ `+ H( V- Y2 K
481.                     else if (run_size <= 7)
     
482.                     {
     
483.                         /* lengths 5, 6, and 7 are 4 bits */
     4 Q$ P" v/ }8 \/ I5 B/ X5 }2 A
484.                         put_bits(pb, run_size + 7, 4);
     
485.                     }
       g0 k) Z- o* Y! T2 G0 r7 w  @
486.                     else
     
487.                     {
     6 y2 Y8 g1 t: b
488.                         /* arbitrary length; start by encoding 0xF which
     0 p* c* Q6 L- H% z  }; ?
489.                          * stands in for an initial version of 8 */
     ! h& C; L7 u# Z3 l* [" L, W' ~0 a/ y
490.                         put_bits(pb, 0xF, 4);
     
491.                         run_size -= 8;
     
492. 
     
493.                         /* encode blocks of 4 bits until run_size is 0 */
     
494.                         while (run_size >= 0)
     
495.                         {
     
496.                             if (run_size >= 15)
     
497.                             {
     ' u4 l8 k8 B; Q' ?2 A! O5 @7 n' C
498.                                 put_bits(pb, 0xF, 4);
     ; l8 C* M! u! ]" q7 M: l* b
499.                                 run_size -= 0xF;
     - W* S2 V0 {  n' Q
500.                             }
     
501.                             else
     % a# u. G5 \5 h4 U
502.                             {
     " {3 t8 H/ h6 |0 x
503.                                 put_bits(pb, run_size, 4);
     0 n% d9 {( k" {
504.                                 run_size = -1;
     
505.                             }
     7 ?/ N8 d- ^1 D& w$ K# Z
506.                         }
     
507.                     }
     * z; `/ V5 P- M
508.                 }
     
509. 
     & J4 U: Z. x+ R: Z: x2 g/ e
510.                 last_pixel = full_window[x];
     ( d4 I: J- b& H7 c1 h* q) A
511.                 run_size = 1;
     
512. 
     ( Q% r4 j2 q$ |! ^4 q
513.                 /* this single x iteration was only here to close the final run */
     
514.                 if (y == window_bottom)
     
515.                     break;
     1 _' S% X% u9 w5 \* J) ^, e
516.             }
     
517.         }
     
518.     }
     % h& D* ~8 b, {0 ]& Q. |# O
519. 
     & h7 S8 O7 N* O
520.     /* close the bitstream by encoding a back reference with length 0 */
     0 {# n/ i' O5 p1 i' n
521.     put_bits(pb, 1, 1);  /* back reference run */
     
522.     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     6 A( g' L9 E5 p" U: |1 G: V0 o
523.     put_bits(pb, 0, 7);  /* length 0 */
     
524. 
     
525.     put_bits_flush(pb);
     
526. }
     ! Z* U+ g. q+ k6 {# y- ?1 p
527. 
     # B3 C3 ]2 }$ ?0 S4 z; s
528. /* compute Euclidean distance between an RGB color and the desired target */
     3 V# F/ W  v+ U& U! t1 ^/ T
529. static int compute_rgb_distance(int r1, int r2, int g1, int g2, int b1, int b2)
       Q5 A/ N) [! \# }$ F4 }% N
530. {
     
531.     return sqrt((r1 - r2) * (r1 - r2) +
       e- {+ x6 p" ]' P1 T  m
532.                 (g1 - g2) * (g1 - g2) +
     : ^3 D- b( Q2 T5 V1 U: q
533.                 (b1 - b2) * (b1 - b2));
     
534. }
     
535. 
     4 K; q. e( y* Z- y: c; N7 N
536. static uint8_t find_nearest_color(rbt_dec_context *rbt, int r, int g, int b)
     : M* s6 B* Y, h2 v& d
537. {
     ' [4 B' J* l- k
538.     int i;
     
539.     int nearest_distance;
     
540.     int distance;
     
541.     int rp;
       V1 @% H$ b; w  A! e7 [0 y
542.     int gp;
     2 h  I7 t& Z9 N1 Q9 i$ z! b3 S  F
543.     int bp;
     / J9 t/ J1 \! s* [4 i1 M' P  W7 r, l+ G
544.     uint8_t palette_index;
     
545. 
     " e9 z8 ]& V6 k2 \- F5 X
546.     nearest_distance = 999999999;
     - K& k4 m: _9 c. u& t
547.     palette_index = 0;
     
548.     for (i = 0; i < 256; i++)
     
549.     {
       M9 ^! B/ G3 }$ u4 S7 |" \6 p' z
550.         rp = rbt->palette[i * 3 + 0];
     
551.         gp = rbt->palette[i * 3 + 1];
     
552.         bp = rbt->palette[i * 3 + 2];
     
553.         distance = compute_rgb_distance(r, rp, g, gp, b, bp);
     : s# I  h' L( q- z0 o  |
554.         if (distance < nearest_distance)
     ! k( ]& ~$ F2 a; C1 v
555.         {
     
556.             nearest_distance = distance;
     ; {) f1 U! t/ M2 Y9 B
557.             palette_index = i;
     
558.         }
     
559.         /* can't get closer than 0; break early */
     
560.         if (distance == 0)
     3 U& L# I/ `% L/ F
561.             break;
     
562.     }
     
563. 
     
564.     return palette_index;
     
565. }
     ! I1 A& r  M" ^* l& T: M: `
566. 
     ; L6 S2 B9 W1 C* z) u: Q4 ]
567. static void subtitle_frame(rbt_dec_context *rbt, uint8_t *frame,
     3 X5 x* Z  ~) z' i, \
568.     int width, int height, int timestamp)
     " v- b$ B6 @, i: k1 K5 X
569. {
     % z! ~9 v& d2 I( _; Z
570.     ASS_Image *subtitles;
     ) k9 E4 d6 ~( \  A
571.     int detect_change;
     . r! E0 a( y& e
572.     uint8_t subtitle_pixel;
     1 T$ B. {7 l: P
573.     int x, y;
     
574.     uint8_t *frame_ptr;
     * |! M$ ~' z* D/ d# A, j
575.     uint8_t *subtitle_ptr;
     
576. 
     
577.     /* ask library for the subtitle for this timestamp */
     1 i- e. I& T  U  M
578.     subtitles = ass_render_frame(rbt->ass_renderer, rbt->ass_track,
     / Y* N: S/ w, L5 u3 h
579.         timestamp, &detect_change);
     ; c1 f7 N* o; m- ]& f: W: W
580. 
     / P4 c8 w/ ]2 d2 F8 e
581.     /* render the list of subtitles onto the decoded frame */
     ; r+ t/ ^; u6 F" B3 y* `! n. p
582.     while (subtitles)
     0 q1 J% e1 J# h+ [4 G9 R% c
583.     {
     % l: d1 J; T# `
584.         /* palette components are only 6 bits, so shift an extra 2
     4 E9 G' U: M: ~& m6 r+ N, U
585.          * bits off each component */
     & j& K7 K; f+ R0 D0 J. e% r
586.         subtitle_pixel = find_nearest_color(rbt,
     + n% y7 d% a. m; P6 x
587.             (subtitles->color >> 10) & 0xFF,
     
588.             (subtitles->color >> 18) & 0xFF,
     0 g" u6 ]* n$ y7 I  V
589.             (subtitles->color >> 26) & 0xFF);
     
590.         for (y = 0; y < subtitles->h; y++)
     
591.         {
     
592.             subtitle_ptr = &subtitles->bitmap[y * subtitles->stride];
     
593.             frame_ptr = &frame[(subtitles->dst_y + y) * width + subtitles->dst_x];
     
594.             for (x = 0; x < subtitles->w; x++, frame_ptr++, subtitle_ptr++)
     : ~1 p+ S& {2 r+ d) O; x6 O
595.             {
     * [1 J$ I. M4 F' a5 {# B
596.                 if (*subtitle_ptr >= SUBTITLE_THRESHOLD)
     
597.                     *frame_ptr = subtitle_pixel;
     
598.             }
     
599.         }
     
600.         subtitles = subtitles->next;
     5 C* Z! u- t& N- q2 k) C6 j) O0 D! h: R
601.     }
     9 [" O' g7 }' Q
602. }
     
603. 
     0 X) v. U. M5 m0 f$ {' ~. V
604. static int copy_frames(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file,
     - ~: }* V2 W3 J1 u9 k1 k
605.     int origin_x, int origin_y, int window_width, int window_height)
     
606. {
     - ?$ |4 C1 ?& x  n" F  R
607.     int i;
     2 L5 {& R  Q; {9 R9 o) J9 b/ r& W  C
608.     int j;
     
609.     int scale;
     
610.     int width;
     # g, Y' o) o7 ~8 T
611.     int height;
     9 {; E6 n8 l4 q. O' E
612.     int max_width;
     7 Q4 C3 B3 X" I9 W2 U
613.     int max_height;
     ; |% W, Y8 v# _3 a/ @/ U
614.     int frame_x;
     , x4 H9 {' c: n' N  y# ?
615.     int frame_y;
     3 k5 b9 g1 u7 w) [
616.     int fragment_count;
     
617.     int decoded_size;
     1 d  L, H; u) ^& P! S# H
618.     uint8_t *decoded_frame;
     
619.     int fragment;
     # [/ H2 n: a# f, k2 N5 l
620.     int fragment_compressed_size;
     
621.     int fragment_decompressed_size;
     7 C7 X# }1 [' L( @# _+ N: w- z
622.     int compression_type;
     
623.     int index;
     
624.     int out_index;
     
625.     get_bits_context gb;
     3 j. a6 }; i0 q
626.     int frame_size;
     $ R: Q8 p3 q! E  q" g) f( y
627.     int video_frame_size;
     
628.     int audio_frame_size;
     ( f) V5 K3 e. R; A+ A6 l
629. 
     
630.     int back_ref_offset_type;
     
631.     int back_ref_offset;
     0 q% h4 x- `. s6 H
632.     int back_ref_length;
     % `3 W7 v6 I  Q4 k2 m' j! `; s
633.     int back_ref_start;
     , v) m' |1 |% ?1 y& z' Q
634.     int back_ref_end;
     
635. 
     + I: s$ l7 r' o' A' `9 [
636.     uint8_t *full_window;
     
637.     int full_window_size;
     
638.     int y;
     
639.     int window_top;
     
640.     int window_bottom;
     0 K( b8 a( c! J; d# ?5 t0 B5 A
641.     int window_left;
     * d8 x9 {8 U9 u6 _! X
642.     int window_right;
     
643.     int window_size;
     0 [& x1 z& y. O& l* o
644. 
     ( N" r* e+ J; j+ J7 Y
645.     char filename[30];
     
646. 
     " a$ @2 U  k! I0 n+ o
647.     put_bits_context *pb;
     
648. 
     5 e+ I2 c. d; N1 S
649.     full_window_size = window_width * window_height;
     
650.     full_window = malloc(full_window_size);
     0 v, q* h6 m' ~7 _
651.     pb = init_put_bits();
     - g: O9 ]$ N2 U. U0 R. M
652. 
     
653.     max_width = 0;
     
654.     max_height = 0;
     & J. b3 _1 K5 T: g2 G8 l3 D
655. 
     
656.     for (i = 0; i < rbt->frame_count; i++)
     
657.     {
     1 u+ ?$ ]0 [& I; L4 d* {
658.         /* read the entire frame (includes audio and video) */
     : A+ V. d! n. o1 F& d. W
659.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     
660.         video_frame_size = LE_16(&rbt->video_frame_size_table[i*2]);
     
661.         audio_frame_size = frame_size - video_frame_size;
     7 R3 z" T$ m) P4 w4 G: o
662.         if (fread(rbt->frame_load_buffer, frame_size, 1, inrbt_file) != 1)
     9 d* k! J" ?$ d
663.         {
     
664.             printf("problem reading frame %d\n", i);
     
665.             return 0;
     ' p7 Y- Q- K* z
666.         }
     
667. 
     
668.         scale = rbt->frame_load_buffer[3];
     4 n7 g7 n8 Q9 b/ D% s
669.         width = LE_16(&rbt->frame_load_buffer[4]);
     5 ^' K7 p* z5 \! i4 y3 }( U
670.         if (max_width < width)
     / J1 q5 @+ T$ o# J
671.             max_width = width;
     
672.         if (max_height < height)
     5 p' i. H8 J2 ?' K' K, }
673.             max_height = height;
     2 d) A6 X$ f) e& }
674.         height = LE_16(&rbt->frame_load_buffer[6]);
     ! Y, c6 @! m) v+ G& ^- M( o2 P
675.         frame_x = LE_16(&rbt->frame_load_buffer[12]);
     
676.         frame_y = LE_16(&rbt->frame_load_buffer[14]);
     + I( l/ E( ^/ l2 G" x
677.         fragment_count = LE_16(&rbt->frame_load_buffer[18]);
     
678.         decoded_size = width * height;
     6 P" |1 J2 g5 c) }! G/ i7 V6 w, @( m
679. 
     
680.         printf("processing frame %d: %d%%, %dx%d, origin @ (%d, %d), %d fragments\n", i, scale, width, height, frame_x, frame_y, fragment_count);
     
681. 
     
682.         /* decode the frame */
     
683.         decoded_frame = malloc(decoded_size);
     & O1 g% o! Y1 X# @* U2 a! D
684.         index = 24;
     9 o( `& G/ a9 W
685.         out_index = 0;
     
686.         for (fragment = 0; fragment < fragment_count; fragment++)
     4 Z4 A0 I' b) T) M0 h  o7 {' s+ J
687.         {
     ; @4 j2 {- C& Z( ^
688.             fragment_compressed_size = LE_32(&rbt->frame_load_buffer[index]);
     
689.             index += 4;
     
690.             fragment_decompressed_size = LE_32(&rbt->frame_load_buffer[index]);
     
691.             index += 4;
     
692.             compression_type = LE_16(&rbt->frame_load_buffer[index]);
     / Z( Y& M0 m% R/ x: y4 V5 v  K3 \
693.             index += 2;
     9 r& g: `3 E  W& `1 C: W
694. 
       r+ j6 s+ L. e3 X& O/ y
695.             if (compression_type == 0)
     
696.             {
     
697.                 init_get_bits(&gb, &rbt->frame_load_buffer[index],
     
698.                     fragment_compressed_size);
     
699. 
     
700.                 while (out_index < fragment_decompressed_size)
     
701.                 {
     ) P2 A  d5 G: m9 H* A/ }  `! A. w
702.                     if (read_bits(&gb, 1))
     " f  x+ x$ I% x, s# z% l& m
703.                     {
     0 q! |' Q4 Q2 M# |3 P
704.                         /* decode back reference offset type */
     
705.                         back_ref_offset_type = read_bits(&gb, 1);
     
706. 
     
707.                         /* back reference offset is 7 or 11 bits */
     
708.                         back_ref_offset = read_bits(&gb,
     
709.                             (back_ref_offset_type) ? 7 : 11);
     
710. 
     8 d  i0 J4 i! Z* T
711.                         /* get the length of the back reference */
     1 K1 h9 `- ~' {4 i( F5 D, X0 X8 \
712.                         back_ref_length = get_lzs_back_ref_length(&gb);
     
713.                         back_ref_start = out_index - back_ref_offset;
     
714.                         back_ref_end = back_ref_start + back_ref_length;
     
715. 
     
716.                         /* copy the back reference, byte by byte */
       U! x! ^% `. Y7 G' d. U
717.                         for (j = back_ref_start; j < back_ref_end; j++)
     ( f% u+ S+ S" F, j9 n" C$ G
718.                             decoded_frame[out_index++] = decoded_frame[j];
     
719.                     }
     ( I8 T0 [) o2 e3 {' c
720.                     else
     
721.                     {
     
722.                         /* read raw pixel byte */
     4 g; H/ ~3 V0 O3 n  w" |
723.                         decoded_frame[out_index++] = read_bits(&gb, 8) & 0xFF;
     
724.                     }
     
725.                 }
     " v: O& f3 s/ ^# @  q% {2 O
726. 
     # p6 a& ]1 Q% i. ?% Y5 k7 ^: r. D" B
727.                 delete_get_bits(&gb);
     . G& T4 R# a1 m' }2 @2 P
728.             }
     
729. 
     
730.             /* next fragment */
     7 e. F5 S: X' U# s8 e% d; K
731.             index += fragment_compressed_size;
     2 c* X# B1 m8 t& \' N* C8 K8 P
732.         }
     
733. 
     
734.         if (rbt->dump_frames)
     ' E6 N! Y" N; U- _- k9 F
735.         {
     
736.             /* dump the original frame */
     
737.             sprintf(filename, "original-frame-%03d.pnm", i);
     % J3 M+ Q3 \2 }% C5 T# o* V" [2 O- o
738.             dump_pnm_file(filename, rbt, decoded_frame, width, height);
     
739.         }
     * T" S3 |, P& E* a( U) h
740. 
     
741.         /* transfer the image onto the frame window */
     8 t- B8 G- @* e# q6 W/ T
742.         memset(full_window, 0xFF, full_window_size);
     6 U9 \% g) d% T
743.         index = 0;
     / P; K# q3 _$ V
744.         for (y = 0; y < height; y++)
     
745.         {
     
746.             out_index = window_width * (frame_y + y) + frame_x;
     * s* S! W. D/ Z* s
747.             memcpy(&full_window[out_index], &decoded_frame[index], width);
       D% H" p: C# D. R) W# O" x
748.             index += width;
     ; E) L, c9 U4 B$ i$ o8 F
749.         }
     2 }% G5 s3 M- A/ @7 j
750. 
     , B' u5 a% D) e; n1 s0 [
751.         /* write the subtitle */
     
752.         subtitle_frame(rbt, full_window, window_width, window_height,
     - A$ ?6 f+ u' g; T
753.             i * MILLISECONDS_PER_FRAME);
     
754. 
     
755.         /* figure out the smallest change window */
     + \+ u. K2 y) D! d( f* X" n
756.         window_top = frame_y;
     * w* U* A( B5 R. C, A, G
757.         window_bottom = window_height;
     ' \# C' P. r/ j& B' K
758.         window_left = 0;
     * f5 p) d, y4 I* ?2 U2 p
759.         window_right = window_width;
     
760.         window_size = (window_right - window_left) * (window_bottom - window_top);
     
761. 
     
762.         /* compress the frame */
     
763.         reset_put_bits(pb);
     2 @& H3 h7 Y3 Z, l) g
764.         compress_window(pb, full_window, window_width, window_top,
     
765.             window_bottom, window_left, window_right);
     
766. 
     0 ]- k& T3 Y2 R& S8 Y
767.         if (rbt->dump_frames)
     " E7 w: V7 v) `( Z) M
768.         {
     
769.             /* dump the frame plotted onto the full window prior to encoding,
     # m' r- ^+ l% V, }
770.              * with subtitle */
     
771.             sprintf(filename, "pre-encoding-frame-%03d.pnm", i);
     
772.             dump_pnm_file(filename, rbt, full_window, window_width, window_height);
     
773.         }
     
774. 
     
775.         free(decoded_frame);
     
776. 
     9 E1 o) s2 W  ~8 e
777.         /* update the frame header */
     
778.         /* width */
     1 \+ q3 [9 b0 o
779.         rbt->frame_load_buffer[4] = (window_right - window_left) & 0xFF;
     
780.         rbt->frame_load_buffer[5] = (window_right - window_left) >> 8;
     / l+ o$ B* C2 V) ~
781.         /* height */
     
782.         rbt->frame_load_buffer[6] = (window_bottom - window_top) & 0xFF;
     . V# H9 [7 f8 s
783.         rbt->frame_load_buffer[7] = (window_bottom - window_top) >> 8;
     
784.         /* origin X */
     
785.         rbt->frame_load_buffer[12] = window_left & 0xFF;
     * W! p" X3 i* [2 e/ x, Z3 F* Z
786.         rbt->frame_load_buffer[13] = window_left >> 8;
     
787.         /* origin Y */
     # }6 c' B+ M! l  v+ f3 D9 V$ B
788.         rbt->frame_load_buffer[14] = window_top & 0xFF;
     
789.         rbt->frame_load_buffer[15] = window_top >> 8;
     . j: u( L" F1 F0 G( j
790.         /* fragment payload size */
     
791.         rbt->frame_load_buffer[16] = (pb->byte_index + 10) & 0xFF;
     
792.         rbt->frame_load_buffer[17] = (pb->byte_index + 10) >> 8;
     6 S8 O2 g2 |# ^  r! V% c$ K/ B
793.         /* fragment count (1) */
     ' o/ T7 o5 ]7 Z. I4 {% D! U( J9 W
794.         rbt->frame_load_buffer[18] = 1;
     * m+ @' R4 Y5 T& G3 T! B" X
795.         rbt->frame_load_buffer[19] = 0;
     - e4 K& a: v( l6 `& K/ w1 x+ L
796. 
     / [$ M5 [$ V7 B/ y: X" A( O
797.         /* update the fragment header */
     
798.         /* compressed size */
     * n6 o" [5 L5 G) V
799.         rbt->frame_load_buffer[24 + 0] = (pb->byte_index >>  0) & 0xFF;
     ; S* L8 ~4 k# D% I1 J: O1 Z8 F
800.         rbt->frame_load_buffer[24 + 1] = (pb->byte_index >>  8) & 0xFF;
     
801.         rbt->frame_load_buffer[24 + 2] = (pb->byte_index >> 16) & 0xFF;
     $ w5 c) K  ]& k& ~# Z) q. n
802.         rbt->frame_load_buffer[24 + 3] = (pb->byte_index >> 24) & 0xFF;
     $ e+ `- q2 N5 |  Q1 X, }3 B/ H
803.         /* decompressed size */
     9 z1 }# g/ D6 }
804.         rbt->frame_load_buffer[24 + 4] = (window_size >>  0) & 0xFF;
     
805.         rbt->frame_load_buffer[24 + 5] = (window_size >>  8) & 0xFF;
     
806.         rbt->frame_load_buffer[24 + 6] = (window_size >> 16) & 0xFF;
     
807.         rbt->frame_load_buffer[24 + 7] = (window_size >> 24) & 0xFF;
     
808.         /* compression format 0 */
     0 a' T( z# }1 @4 R
809.         rbt->frame_load_buffer[24 + 8] = 0;
     
810.         rbt->frame_load_buffer[24 + 9] = 0;
     
811. 
     
812.         /* write the 24-byte frame header and the 10-byte fragment header */
     
813.         if (fwrite(rbt->frame_load_buffer, 24 + 10, 1, outrbt_file) != 1)
     5 Y9 o- F% c! y- g
814.         {
     1 E! T" ^5 Q% i
815.             printf("problem writing frame %d\n", i);
     
816.             return 0;
     
817.         }
     
818. 
     
819.         /* write the new compressed frame data */
     
820.         if (fwrite(pb->bytes, pb->byte_index, 1, outrbt_file) != 1)
     8 N% S1 y. G$ w1 C& n5 n
821.         {
     ( N, N* p' b: a, K
822.             printf("problem writing frame %d\n", i);
     
823.             return 0;
     / B2 z+ N6 W3 V1 K& S% K" }
824.         }
     7 k# B% B* j; M/ A3 c
825. 
     
826.         /* write the audio data */
     - n2 V2 d- o4 [6 K
827.         if (fwrite(&rbt->frame_load_buffer[video_frame_size], frame_size - video_frame_size, 1, outrbt_file) != 1)
     
828.         {
     : G9 b. U9 ~: r$ W7 _9 Z8 x
829.             printf("problem writing frame %d\n", i);
     5 b8 ~& ?9 d6 f$ P; Y
830.             return 0;
     * x+ m4 u6 X' `" z7 W! j
831.         }
     ) t/ z/ R5 g: `2 s- f6 I! e
832. 
     / [. `' d2 x9 j5 G* r0 a
833.         /* update the table entries */
     2 ?! J$ \% _. o+ h" `. m" F
834.         video_frame_size = pb->byte_index + 24 + 10;
     % I2 I9 h  A: N, `
835.         frame_size = video_frame_size + audio_frame_size;
     ) U) _; o& K% v; t) q
836.         rbt->frame_size_table[i*2+0] = frame_size & 0xFF;
     
837.         rbt->frame_size_table[i*2+1] = frame_size >> 8;
     0 h6 B. o6 d6 I; u, c, `+ C
838.         rbt->video_frame_size_table[i*2+0] = video_frame_size & 0xFF;
     
839.         rbt->video_frame_size_table[i*2+1] = video_frame_size >> 8;
     6 x, a! J7 p) _! K# \
840.     }
     3 c% a9 V. v/ Y  A
841. 
     % ^* s% j  r: [8 R
842.     printf("maximum dimensions seen are %dx%d\n", max_width, max_height);
     
843. 
     
844.     delete_put_bits(pb);
     $ E# E/ I% y( q% v1 B. b
845.     free(full_window);
     , w+ |( X  b6 a
846. 
     * l* `, }7 l( l) e
847.     return 1;
     
848. }
     
849. 
     
850. int main(int argc, char *argv[])
     
851. {
     ' H' r7 m4 o' h( Z
852.     char *subtitle_filename;
     ( i# k% x0 E/ `* y; Y9 s( {
853.     FILE *subtitle_file;
     
854.     char *inrbt_filename;
     
855.     FILE *inrbt_file;
     ' ]9 G8 a: ]4 L% K1 U0 i! a
856.     char *outrbt_filename;
     2 P% e# X+ ?% ^/ a: h9 U
857.     FILE *outrbt_file;
     
858.     rbt_dec_context rbt;
     1 i; q$ R. R5 ~2 A+ d$ L
859.     int origin_x;
     
860.     int origin_y;
     
861.     int window_width;
     
862.     int window_height;
     
863. 
     
864.     /* testing the bit functions */
     9 [, x4 A1 m! H. z8 K2 B& k
865. #if 0
     
866.     int i;
     
867.     uint8_t bytestream[] = { 0x55, 0xAA, 0x00, 0xAA, 0x55, 0x77, 0xFF, 0x1B, 0x70, 0x8F };
     
868.     int bytestream_size = 10;
     
869.     get_bits_context gb;
     
870.     put_bits_context *pb;
     " d( ~, y% D4 Z9 v
871.     int bits;
     8 m7 [9 L/ D2 S+ Y: ~
872. 
     
873.     init_get_bits(&gb, bytestream, bytestream_size);
     ; Q7 c9 I) s8 D! h; u
874.     pb = init_put_bits();
     
875. 
     
876.     for (i = 1; i <= 12; i++)
     6 ^, f" U2 g/ y2 Q# ]& \  m
877.     {
     
878.         bits = view_bits(&gb, i);
     6 \5 q2 `! q/ B( S
879.         printf("view %d bits: %d\n", i, bits);
     
880.         printf("read %d bits: %d\n", i, read_bits(&gb, i));
     
881.         put_bits(pb, bits, i);
     
882.     }
     
883.     put_bits_flush(pb);
     
884. 
     
885.     printf("original bytestream:\n");
     
886.     for (i = 0; i < bytestream_size; i++)
     
887.         printf(" %02X", bytestream[i]);
     5 v! s: i; @% o0 K& E  k$ t' e
888.     printf("\nnewbytestream:\n");
     
889.     for (i = 0; i < pb->byte_index; i++)
     ' w7 c* [; X! W
890.         printf(" %02X", pb->bytes[i]);
     
891.     printf("\n");
     
892. 
     + m; c( I4 |, F# \6 f) Y
893.     delete_get_bits(&gb);
     
894.     free(pb);
     - S- Q7 k8 O8 c# c  c9 S
895. #endif
     
896. 
     7 ]$ K% T+ p1 k4 x, |
897.     /* validate the number of arguments */
     $ N' Z: x; n/ k' O( G5 b
898.     if (argc != 8 && argc != 9)
     
899.     {
     9 O: F  x* E2 Z+ x. u
900.         printf("USAGE: subtitle-rbt <subtitles.ass> <in.rbt> <out.rbt> <origin X> <origin Y> <width> <height> [dump_frames]\n");
     2 m$ |( L) P( j
901.         return 1;
     3 Y7 @6 k$ K4 O1 ?
902.     }
     
903.     subtitle_filename = argv[1];
     
904.     inrbt_filename = argv[2];
     ' j- N2 h& J; k2 I5 |$ m7 `
905.     outrbt_filename = argv[3];
     ; ]3 R# H2 z! q, u1 a9 p
906.     origin_x = atoi(argv[4]);
     8 ~: j  @* h3 p1 t0 ]
907.     origin_y = atoi(argv[5]);
     
908.     window_width = atoi(argv[6]);
     
909.     window_height = atoi(argv[7]);
     
910.     rbt.dump_frames = 0;
     * V/ {' L& H5 v* W* Z; y+ \% R
911.     if (argc == 9)
     
912.         rbt.dump_frames = 1;
     
913. 
     ! p' \& P' q$ b  w- F- u8 J; d
914.     /* verify that the specified input files are valid */
     
915.     subtitle_file = fopen(subtitle_filename, "r");
     
916.     if (!subtitle_file)
     
917.     {
     
918.         perror(subtitle_filename);
     9 s/ y' M' B) s! j
919.         return 1;
     - O- D7 ~* @# p0 M
920.     }
     
921.     fclose(subtitle_file);
     ; j( ~( D" t5 `; o
922.     inrbt_file = fopen(inrbt_filename, "rb");
     
923.     if (!inrbt_file)
     9 S* f# F+ o! I/ k+ L! W( k
924.     {
     
925.         perror(inrbt_filename);
     
926.         return 1;
     5 O: L0 U; ~0 ]1 x  F1 |7 e( O& a  }
927.     }
     
928. 
     5 g; h- ~3 L, q, W; \
929.     /* initialize the subtitle support */
     ; Z% O/ w9 ]# [
930.     rbt.ass_lib = ass_library_init();
     
931.     rbt.ass_renderer = ass_renderer_init(rbt.ass_lib);
     . N% `$ ?. N/ B6 I% y
932.     rbt.ass_track = ass_read_file(rbt.ass_lib, subtitle_filename, "UTF-8");
     6 u" ?8 X' B" E$ R2 g0 B! g
933.     ass_set_frame_size(rbt.ass_renderer, window_width, window_height);
     1 D, L/ e3 U6 Z% x0 Z5 s
934.     ass_set_fonts(rbt.ass_renderer, NULL, NULL, 1, NULL, 1);
     
935. 
     # v' H" m- ]2 i! Q8 N
936.     /* open the output file */
     
937.     outrbt_file = fopen(outrbt_filename, "wb");
     
938.     if (!outrbt_file)
     6 P2 G3 u" V$ @& g8 ^* A
939.     {
     
940.         perror(outrbt_filename);
     
941.         return 1;
     : C2 W8 ?) r4 s: z' [- e2 G
942.     }
     / o: n2 z% |4 H( K# G/ }( H
943. 
     
944.     /* transfer header from input to output */
     % J7 R5 b: |' t0 y5 A/ J+ W  ^9 X
945.     if (!load_and_copy_rbt_header(&rbt, inrbt_file, outrbt_file))
     
946.         return 1;
     
947. 
     
948.     /* rewrite the frames */
     0 I' o' n7 {! }  e+ w1 a
949.     if (!copy_frames(&rbt, inrbt_file, outrbt_file, origin_x, origin_y,
     : X- u- C* r8 n" p
950.         window_width, window_height))
     1 B) N/ @# U/ P3 m* J' l. q& Y
951.         return 1;
     
952. 
     
953.     /* write the modified frame size tables back to the file */
     ) k) ^# h' r3 D7 s. q
954.     fseek(outrbt_file, rbt.video_frame_size_table_offset, SEEK_SET);
     ! q8 h7 |, x+ J* y- Z8 w* h0 h
955.     fwrite(rbt.video_frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
       ~8 X' s8 v: p" n
956.     fseek(outrbt_file, rbt.frame_size_table_offset, SEEK_SET);
     
957.     fwrite(rbt.frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
     7 ?+ w6 W. W5 G+ Y5 ^6 L
958. 
     
959.     /* finished with files */
     / k6 o& ]1 c& C+ |- ]9 g
960.     fclose(inrbt_file);
     9 ^4 ?$ J7 u3 |1 b# \# D
961.     fclose(outrbt_file);
     
962. 
     . E# K# q3 M( x2 `: A( p4 E
963.     /* clean up subtitle library */
     
964.     ass_free_track(rbt.ass_track);
     
965.     ass_renderer_done(rbt.ass_renderer);
     , [/ S" [% O  C+ r3 q0 C
966.     ass_library_done(rbt.ass_lib);
     
967. 
       C  Y- F- }  O! T5 w% N8 m: U# A
968.     /* clean up */
     8 M7 w8 W& `& O+ z9 Q, y/ g: D
969.     free(rbt.frame_load_buffer);
     
970.     free(rbt.video_frame_size_table);
     4 C% J# c% J2 w# C" B/ k- a
971.     free(rbt.frame_size_table);
     # ~, I/ J! p8 F# X* Y( |
972. 
     , t) @3 d7 j6 r! Z
973.     return 0;
     
974. }

复制代码

2 i/ u8 o0 t4 L7 m3 \- V7 X# W
3 O$ `* u: C: Q! Q8 G$ m7 Q" X

soring123

这游戏有字幕吗？

shane007

引用第1楼soring123于2009-11-19 11:09发表的  :
这游戏有字幕吗？

好像没有字幕，我说的是给视频外挂字幕方式的汉化。
7 I) R' q- @* Y! o* L3 v就像syberia2汉化版下面那行字一样。

soring123

我记得是没字幕的 比较麻烦 都是视频的

shane007

引用第3楼soring123于2009-11-19 17:07发表的  :
0 G5 F$ A8 Z; l: [我记得是没字幕的 比较麻烦 都是视频的

, I6 d: i7 [. y( G7 o给视频外挂字幕方式汉化也许能行。
要结合dosbox和代理dll技术。

宿矢

求汉化啊！

shane007

顶上来